Index: trunk/src/variables/variables.nw
===================================================================
--- trunk/src/variables/variables.nw	(revision 8163)
+++ trunk/src/variables/variables.nw	(revision 8164)
@@ -1,6703 +1,6755 @@
 % -*- ess-noweb-default-code-mode: f90-mode; noweb-default-code-mode: f90-mode; -*-
 % WHIZARD code as NOWEB source: variables for processes
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Variables for Processes}
 \includemodulegraph{variables}
 
 This part introduces variables as user-controlled objects that
 influence the behavior of objects and calculations.  Variables contain
 objects of intrinsic type or of a type as introced above.
 \begin{description}
 \item[variables]
   Store values of various kind, used by expressions and accessed by
   the command interface.  This provides an implementation of the [[vars_t]]
   abstract type.
 \item[observables]
   Concrete implementation of observables (functions in the variable tree),
   applicable for \whizard.
   abstract type.
 \end{description}
 
 \clearpage
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Variables: Implementation}
 The user interface deals with variables that are handled similarly to
 full-flegded programming languages.  The system will add a lot of
 predefined variables (model parameters, flags, etc.) that are
 accessible to the user by the same methods.
 
 Variables can be of various type: logical (boolean/flag), integer,
 real (default precision), subevents (used in cut expressions),
 arrays of PDG codes (aliases for particles), strings.  Furthermore, in
 cut expressions we have unary and binary observables, which are used
 like real parameters but behave like functions.
 <<[[variables.f90]]>>=
 <<File header>>
 
 module variables
 
 <<Use kinds>>
 <<Use strings>>
   use io_units
   use format_utils, only: pac_fmt
   use format_defs, only: FMT_12, FMT_19
   use constants, only: eps0
   use os_interface, only: paths_t
   use physics_defs, only: LAMBDA_QCD_REF
   use system_dependencies
   use fastjet !NODEP!
   use diagnostics
   use pdg_arrays
   use subevents
 
   use var_base
 
 <<Standard module head>>
 
 <<Variables: public>>
 
 <<Variables: parameters>>
 
 <<Variables: types>>
 
 <<Variables: interfaces>>
 
 contains
 
 <<Variables: procedures>>
 
 end module variables
 @ %def variables
 @
 \subsection{Variable list entries}
 Variable (and constant) values can be of one of the following types:
 <<Variables: parameters>>=
   integer, parameter, public :: V_NONE = 0, V_LOG = 1, V_INT = 2, V_REAL = 3
   integer, parameter, public :: V_CMPLX = 4, V_SEV = 5, V_PDG = 6, V_STR = 7
   integer, parameter, public :: V_OBS1_INT = 11, V_OBS2_INT = 12
   integer, parameter, public :: V_OBS1_REAL = 21, V_OBS2_REAL = 22
   integer, parameter, public :: V_UOBS1_INT = 31, V_UOBS2_INT = 32
   integer, parameter, public :: V_UOBS1_REAL = 41, V_UOBS2_REAL = 42
 
 @ %def V_NONE V_LOG V_INT V_REAL V_CMPLX V_PRT V_SEV V_PDG
 @ %def V_OBS1_INT V_OBS2_INT V_OBS1_REAL V_OBS2_REAL
 @ %def V_UOBS1_INT V_UOBS2_INT V_UOBS1_REAL V_UOBS2_REAL
 @
 \subsubsection{The type}
 This is an entry in the variable list.  It can be of any type; in
 each case only one value is allocated.  It may be physically
 allocated upon creation, in which case [[is_allocated]] is true, or
 it may contain just a pointer to a value somewhere else, in which case
 [[is_allocated]] is false.
 
 The flag [[is_defined]] is set when the variable is given a value, even the
 undefined value.  (Therefore it is distinct from [[is_known]].)  This matters
 for variable declaration in the SINDARIN language.  The variable is set up in
 the compilation step and initially marked as defined, but after compilation
 all variables are set undefined.  Each variable becomes defined when it is
 explicitly set.  The difference matters in loops.
 
 [[is_locked]] means that it cannot be given a value using the interface
 routines [[var_list_set_XXX]] below.  It can only be initialized, or change
 automatically due to a side effect.
 
 [[is_copy]] means that this is a local copy of a global variable.  The copy
 has a pointer to the original, which can be used to restore a previous value.
 
 [[is_intrinsic]] means that this variable is defined by the program, not by
 the user.  Intrinsic variables cannot be (re)declared, but their values can be
 reset unless they are locked.  [[is_user_var]] means that the variable has
 been declared by the user.  It could be a new variable, or a local copy of an
 intrinsic variable.
 
 The flag [[is_known]] is a pointer which parallels the use of the
 value pointer.  For pointer variables, it is set if the value should point to
 a known value.  For ordinary variables, it should be true.
 
 The value is implemented as a set of alternative type-specific pointers.  This
 emulates polymorphism, and it allows for actual pointer variables.
 Observable-type variables have function pointers as values, so they behave
 like macros.  The functions make use of the particle objects accessible via
 the pointers [[prt1]] and [[prt2]].
 
 Finally, the [[next]] pointer indicates that we are making lists of
 variables.  A more efficient implementation might switch to hashes or
 similar; the current implementation has $O(N)$ lookup.
 <<Variables: public>>=
   public :: var_entry_t
 <<Variables: types>>=
   type :: var_entry_t
      private
      integer :: type = V_NONE
      type(string_t) :: name
      logical :: is_allocated = .false.
      logical :: is_defined = .false.
      logical :: is_locked = .false.
      logical :: is_intrinsic = .false.
      logical :: is_user_var = .false.
      logical, pointer :: is_known => null ()
      logical,           pointer :: lval => null ()
      integer,           pointer :: ival => null ()
      real(default),     pointer :: rval => null ()
      complex(default), pointer :: cval => null ()
      type(subevt_t),  pointer :: pval => null ()
      type(pdg_array_t), pointer :: aval => null ()
      type(string_t),    pointer :: sval => null ()
      procedure(obs_unary_int),   nopass, pointer :: obs1_int  => null ()
      procedure(obs_unary_real),  nopass, pointer :: obs1_real => null ()
      procedure(obs_binary_int),  nopass, pointer :: obs2_int  => null ()
      procedure(obs_binary_real), nopass, pointer :: obs2_real => null ()
      type(prt_t), pointer :: prt1 => null ()
      type(prt_t), pointer :: prt2 => null ()
      type(var_entry_t), pointer :: next => null ()
      type(var_entry_t), pointer :: previous => null ()
      type(string_t) :: description
   end type var_entry_t
 
 @ %def var_entry_t
 @
 \subsubsection{Interfaces for the observable functions}
 <<Variables: public>>=
   public :: obs_unary_int
   public :: obs_unary_real
   public :: obs_binary_int
   public :: obs_binary_real
 <<Variables: interfaces>>=
   abstract interface
      function obs_unary_int (prt1) result (ival)
        import
        integer :: ival
        type(prt_t), intent(in) :: prt1
      end function obs_unary_int
   end interface
   abstract interface
      function obs_unary_real (prt1) result (rval)
        import
        real(default) :: rval
        type(prt_t), intent(in) :: prt1
      end function obs_unary_real
   end interface
   abstract interface
      function obs_binary_int (prt1, prt2) result (ival)
        import
        integer :: ival
        type(prt_t), intent(in) :: prt1, prt2
      end function obs_binary_int
   end interface
   abstract interface
      function obs_binary_real (prt1, prt2) result (rval)
        import
        real(default) :: rval
        type(prt_t), intent(in) :: prt1, prt2
      end function obs_binary_real
   end interface
 
 @ %def obs_unary_int obs_unary_real obs_binary_real
 @
 \subsubsection{Initialization}
 Initialize an entry, optionally with a physical value.  We also
 allocate the [[is_known]] flag and set it if the value is set.
 <<Variables: public>>=
   public :: var_entry_init_int
 <<Variables: procedures>>=
   subroutine var_entry_init_log (var, name, lval, intrinsic, user)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     logical, intent(in), optional :: lval
     logical, intent(in), optional :: intrinsic, user
     var%name = name
     var%type = V_LOG
     allocate (var%lval, var%is_known)
     if (present (lval)) then
        var%lval = lval
        var%is_defined = .true.
        var%is_known = .true.
     else
        var%is_known = .false.
     end if
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     if (present (user))  var%is_user_var = user
     var%is_allocated = .true.
   end subroutine var_entry_init_log
 
   subroutine var_entry_init_int (var, name, ival, intrinsic, user)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     integer, intent(in), optional :: ival
     logical, intent(in), optional :: intrinsic, user
     var%name = name
     var%type = V_INT
     allocate (var%ival, var%is_known)
     if (present (ival)) then
        var%ival = ival
        var%is_defined = .true.
        var%is_known = .true.
     else
        var%is_known = .false.
     end if
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     if (present (user))  var%is_user_var = user
     var%is_allocated = .true.
   end subroutine var_entry_init_int
 
   subroutine var_entry_init_real (var, name, rval, intrinsic, user)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     real(default), intent(in), optional :: rval
     logical, intent(in), optional :: intrinsic, user
     var%name = name
     var%type = V_REAL
     allocate (var%rval, var%is_known)
     if (present (rval)) then
        var%rval = rval
        var%is_defined = .true.
        var%is_known = .true.
     else
        var%is_known = .false.
     end if
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     if (present (user))  var%is_user_var = user
     var%is_allocated = .true.
   end subroutine var_entry_init_real
 
   subroutine var_entry_init_cmplx (var, name, cval, intrinsic, user)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     complex(default), intent(in), optional :: cval
     logical, intent(in), optional :: intrinsic, user
     var%name = name
     var%type = V_CMPLX
     allocate (var%cval, var%is_known)
     if (present (cval)) then
        var%cval = cval
        var%is_defined = .true.
        var%is_known = .true.
     else
        var%is_known = .false.
     end if
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     if (present (user))  var%is_user_var = user
     var%is_allocated = .true.
   end subroutine var_entry_init_cmplx
 
   subroutine var_entry_init_subevt (var, name, pval, intrinsic, user)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     type(subevt_t), intent(in), optional :: pval
     logical, intent(in), optional :: intrinsic, user
     var%name = name
     var%type = V_SEV
     allocate (var%pval, var%is_known)
     if (present (pval)) then
        var%pval = pval
        var%is_defined = .true.
        var%is_known = .true.
     else
        var%is_known = .false.
     end if
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     if (present (user))  var%is_user_var = user
     var%is_allocated = .true.
   end subroutine var_entry_init_subevt
 
   subroutine var_entry_init_pdg_array (var, name, aval, intrinsic, user)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     type(pdg_array_t), intent(in), optional :: aval
     logical, intent(in), optional :: intrinsic, user
     var%name = name
     var%type = V_PDG
     allocate (var%aval, var%is_known)
     if (present (aval)) then
        var%aval = aval
        var%is_defined = .true.
        var%is_known = .true.
     else
        var%is_known = .false.
     end if
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     if (present (user))  var%is_user_var = user
     var%is_allocated = .true.
   end subroutine var_entry_init_pdg_array
 
   subroutine var_entry_init_string (var, name, sval, intrinsic, user)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     type(string_t), intent(in), optional :: sval
     logical, intent(in), optional :: intrinsic, user
     var%name = name
     var%type = V_STR
     allocate (var%sval, var%is_known)
     if (present (sval)) then
        var%sval = sval
        var%is_defined = .true.
        var%is_known = .true.
     else
        var%is_known = .false.
     end if
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     if (present (user))  var%is_user_var = user
     var%is_allocated = .true.
   end subroutine var_entry_init_string
 
 @ %def var_entry_init_log
 @ %def var_entry_init_int
 @ %def var_entry_init_real
 @ %def var_entry_init_cmplx
 @ %def var_entry_init_subevt
 @ %def var_entry_init_pdg_array
 @ %def var_entry_init_string
 @ Initialize an entry with a pointer to the value and, for numeric/logical
 values, a pointer to the [[is_known]] flag.
 <<Variables: procedures>>=
   subroutine var_entry_init_log_ptr (var, name, lval, is_known, intrinsic)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     logical, intent(in), target :: lval
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: intrinsic
     var%name = name
     var%type = V_LOG
     var%lval => lval
     var%is_known => is_known
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     var%is_defined = .true.
   end subroutine var_entry_init_log_ptr
 
   subroutine var_entry_init_int_ptr (var, name, ival, is_known, intrinsic)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     integer, intent(in), target :: ival
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: intrinsic
     var%name = name
     var%type = V_INT
     var%ival => ival
     var%is_known => is_known
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     var%is_defined = .true.
   end subroutine var_entry_init_int_ptr
 
   subroutine var_entry_init_real_ptr (var, name, rval, is_known, intrinsic)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     real(default), intent(in), target :: rval
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: intrinsic
     var%name = name
     var%type = V_REAL
     var%rval => rval
     var%is_known => is_known
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     var%is_defined = .true.
   end subroutine var_entry_init_real_ptr
 
   subroutine var_entry_init_cmplx_ptr (var, name, cval, is_known, intrinsic)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     complex(default), intent(in), target :: cval
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: intrinsic
     var%name = name
     var%type = V_CMPLX
     var%cval => cval
     var%is_known => is_known
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     var%is_defined = .true.
   end subroutine var_entry_init_cmplx_ptr
 
   subroutine var_entry_init_pdg_array_ptr (var, name, aval, is_known, intrinsic)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     type(pdg_array_t), intent(in), target :: aval
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: intrinsic
     var%name = name
     var%type = V_PDG
     var%aval => aval
     var%is_known => is_known
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     var%is_defined = .true.
   end subroutine var_entry_init_pdg_array_ptr
 
   subroutine var_entry_init_subevt_ptr (var, name, pval, is_known, intrinsic)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     type(subevt_t), intent(in), target :: pval
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: intrinsic
     var%name = name
     var%type = V_SEV
     var%pval => pval
     var%is_known => is_known
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     var%is_defined = .true.
   end subroutine var_entry_init_subevt_ptr
 
   subroutine var_entry_init_string_ptr (var, name, sval, is_known, intrinsic)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     type(string_t), intent(in), target :: sval
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: intrinsic
     var%name = name
     var%type = V_STR
     var%sval => sval
     var%is_known => is_known
     if (present (intrinsic))  var%is_intrinsic = intrinsic
     var%is_defined = .true.
   end subroutine var_entry_init_string_ptr
 
 @ %def var_entry_init_log_ptr
 @ %def var_entry_init_int_ptr
 @ %def var_entry_init_real_ptr
 @ %def var_entry_init_cmplx_ptr
 @ %def var_entry_init_pdg_array_ptr
 @ %def var_entry_init_subevt_ptr
 @ %def var_entry_init_string_ptr
 @ Initialize an entry with an observable.  The procedure pointer is
 not yet set.
 <<Variables: procedures>>=
   subroutine var_entry_init_obs (var, name, type, prt1, prt2)
     type(var_entry_t), intent(out) :: var
     type(string_t), intent(in) :: name
     integer, intent(in) :: type
     type(prt_t), intent(in), target :: prt1
     type(prt_t), intent(in), optional, target :: prt2
     var%type = type
     var%name = name
     var%prt1 => prt1
     if (present (prt2))  var%prt2 => prt2
     var%is_intrinsic = .true.
     var%is_defined = .true.
   end subroutine var_entry_init_obs
 
 @ %def var_entry_init_obs
 @ Mark an entry as undefined it it is a user-defined variable object, so force
 re-initialization.
 <<Variables: procedures>>=
   subroutine var_entry_undefine (var)
     type(var_entry_t), intent(inout) :: var
     var%is_defined = .not. var%is_user_var
     var%is_known = var%is_defined .and. var%is_known
   end subroutine var_entry_undefine
 
 @ %def var_entry_undefine
 @ Clear an entry: mark it as unknown.
 <<Variables: procedures>>=
   subroutine var_entry_clear (var)
     type(var_entry_t), intent(inout) :: var
     var%is_known = .false.
   end subroutine var_entry_clear
 
 @ %def var_entry_clear
 @ Lock an entry: forbid resetting the entry after initialization.
 <<Variables: procedures>>=
   subroutine var_entry_lock (var, locked)
     type(var_entry_t), intent(inout) :: var
     logical, intent(in), optional :: locked
     if (present (locked)) then
        var%is_locked = locked
     else
        var%is_locked = .true.
     end if
   end subroutine var_entry_lock
 
 @ %def var_entry_lock
 @
 \subsubsection{Finalizer}
 <<Variables: procedures>>=
   subroutine var_entry_final (var)
     type(var_entry_t), intent(inout) :: var
     if (var%is_allocated) then
        select case (var%type)
        case (V_LOG); deallocate (var%lval)
        case (V_INT); deallocate (var%ival)
        case (V_REAL);deallocate (var%rval)
        case (V_CMPLX);deallocate (var%cval)
        case (V_SEV); deallocate (var%pval)
        case (V_PDG); deallocate (var%aval)
        case (V_STR); deallocate (var%sval)
        end select
        deallocate (var%is_known)
        var%is_allocated = .false.
        var%is_defined = .false.
     end if
   end subroutine var_entry_final
 
 @ %def var_entry_final
 @
 \subsubsection{Output}
 <<Variables: procedures>>=
   recursive subroutine var_entry_write (var, unit, model_name, &
        intrinsic, pacified, descriptions, ascii_output)
     type(var_entry_t), intent(in) :: var
     integer, intent(in), optional :: unit
     type(string_t), intent(in), optional :: model_name
     logical, intent(in), optional :: intrinsic
     logical, intent(in), optional :: pacified
     logical, intent(in), optional :: descriptions
     logical, intent(in), optional :: ascii_output
     type(string_t) :: col_string
     logical :: show_desc, ao
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     show_desc = .false.; if (present (descriptions))  show_desc = descriptions
     ao = .false.; if (present (ascii_output))  ao = ascii_output
     if (show_desc) then
        if (ao) then
           col_string = create_col_string (COL_BLUE)
           if (var%is_locked) then
              write (u, "(A)", advance="no") char (achar(27) // col_string) // &
                   char (var%name) // achar(27) // "[0m" //" fixed-value="
           else
              write (u, "(A)", advance="no") char (achar(27) // col_string) // &
                   char (var%name) // achar(27) // "[0m" //" default="
           end if
           col_string = create_col_string (COL_RED)
           write (u, "(A)", advance="no") char (achar(27) // col_string)
           call var_write_val (var, u, "no", pacified=.true.)
           write (u, "(A)") achar(27) // "[0m"
           write (u, "(A)")  char (var%description)
           return
        else
           write (u, "(A)")  "\item"
           write (u, "(A)", advance="no")  "\ttt{" // char ( &
                replace (replace (var%name, "_", "\_", every=.true.), "$", "\$" )) // &
                "} "
           if (var%is_known) then
              if (var%is_locked) then
                 write (u, "(A)", advance="no")  "\qquad (fixed value: \ttt{"
              else
                 write (u, "(A)", advance="no")  "\qquad (default: \ttt{"
              end if
              call var_write_val (var, u, "no", pacified=.true., escape_tex=.true.)
              write (u, "(A)", advance="no")  "})"
           end if
           write (u, "(A)") " \newline"
           write (u, "(A)") char (var%description)
           write (u, "(A)") "%%%%%"
           return
        end if
     end if
     if (present (intrinsic)) then
        if (var%is_intrinsic .neqv. intrinsic)  return
     end if
     if (.not. var%is_defined) then
        write (u, "(A,1x)", advance="no")  "[undefined]"
     end if
     if (.not. var%is_intrinsic) then
        write (u, "(A,1x)", advance="no")  "[user variable]"
     end if
     if (present (model_name)) then
        write (u, "(A,A)", advance="no")  char(model_name), "."
     end if
     write (u, "(A)", advance="no")  char (var%name)
     if (var%is_locked)  write (u, "(A)", advance="no")  "*"
     if (var%is_allocated) then
        write (u, "(A)", advance="no")  " = "
     else if (var%type /= V_NONE) then
        write (u, "(A)", advance="no")  " => "
     end if
     call var_write_val (var, u, "yes", pacified)
   end subroutine var_entry_write
 
 @ %def var_entry_write
 @
 <<Variables: procedures>>=
   subroutine var_write_val (var, u, advance, pacified, escape_tex)
     type(var_entry_t), intent(in) :: var
     integer, intent(in) :: u
     character(*), intent(in) :: advance
     logical, intent(in), optional :: pacified, escape_tex
     logical :: num_pac, et
     real(default) :: rval
     complex(default) :: cval
     character(len=7) :: fmt
     call pac_fmt (fmt, FMT_19, FMT_12, pacified)
     num_pac = .false.; if (present (pacified))  num_pac = pacified
     et = .false.; if (present (escape_tex))  et = escape_tex
     select case (var%type)
     case (V_NONE); write (u, '()', advance=advance)
     case (V_LOG)
        if (var%is_known) then
           if (var%lval) then
              write (u, "(A)", advance=advance)  "true"
           else
              write (u, "(A)", advance=advance)  "false"
           end if
        else
           write (u, "(A)", advance=advance)  "[unknown logical]"
        end if
     case (V_INT)
        if (var%is_known) then
           write (u, "(I0)", advance=advance)  var%ival
        else
           write (u, "(A)", advance=advance)  "[unknown integer]"
        end if
     case (V_REAL)
        if (var%is_known) then
           rval = var%rval
           if (num_pac) then
              call pacify (rval, 10 * eps0)
           end if
           write (u, "(" // fmt // ")", advance=advance)  rval
        else
           write (u, "(A)", advance=advance)  "[unknown real]"
        end if
     case (V_CMPLX)
        if (var%is_known) then
           cval = var%cval
           if (num_pac) then
              call pacify (cval, 10 * eps0)
           end if
           write (u, "('('," // fmt // ",','," // fmt // ",')')", advance=advance)  cval
        else
           write (u, "(A)", advance=advance)  "[unknown complex]"
        end if
     case (V_SEV)
        if (var%is_known) then
           call subevt_write (var%pval, u, prefix="       ", &
                pacified = pacified)
        else
           write (u, "(A)", advance=advance)  "[unknown subevent]"
        end if
     case (V_PDG)
        if (var%is_known) then
           call pdg_array_write (var%aval, u);  write (u, *)
        else
           write (u, "(A)", advance=advance)  "[unknown PDG array]"
        end if
     case (V_STR)
        if (var%is_known) then
           if (et) then
              write (u, "(A)", advance=advance)  '"' // char (replace ( &
                   replace (var%sval, "_", "\_", every=.true.), "$", "\$" )) // '"'
           else
              write (u, "(A)", advance=advance)  '"' // char (var%sval) // '"'
           end if
        else
           write (u, "(A)", advance=advance)  "[unknown string]"
        end if
     case (V_OBS1_INT);  write (u, "(A)", advance=advance) "[int] = unary observable"
     case (V_OBS2_INT);  write (u, "(A)", advance=advance) "[int] = binary observable"
     case (V_OBS1_REAL); write (u, "(A)", advance=advance) "[real] = unary observable"
     case (V_OBS2_REAL); write (u, "(A)", advance=advance) "[real] = binary observable"
     case (V_UOBS1_INT);  write (u, "(A)", advance=advance) "[int] = unary user observable"
     case (V_UOBS2_INT);  write (u, "(A)", advance=advance) "[int] = binary user observable"
     case (V_UOBS1_REAL); write (u, "(A)", advance=advance) "[real] = unary user observable"
     case (V_UOBS2_REAL); write (u, "(A)", advance=advance) "[real] = binary user observable"
     end select
   end subroutine var_write_val
 
 @ %def procedure
 @
 \subsubsection{Accessing contents}
 <<Variables: procedures>>=
   function var_entry_get_name (var) result (name)
     type(string_t) :: name
     type(var_entry_t), intent(in) :: var
     name = var%name
   end function var_entry_get_name
 
   function var_entry_get_type (var) result (type)
     integer :: type
     type(var_entry_t), intent(in) :: var
     type = var%type
   end function var_entry_get_type
 
 @ %def var_entry_get_name var_entry_get_type
 @ Return true if the variable is defined.  This the case if it is allocated
 and known, or if it is a pointer.
 <<Variables: procedures>>=
   function var_entry_is_defined (var) result (defined)
     logical :: defined
     type(var_entry_t), intent(in) :: var
     defined = var%is_defined
   end function var_entry_is_defined
 
 @ %def var_entry_is_defined
 @ Return true if the variable is locked.  If [[force]] is active,
 always return false.
 <<Variables: procedures>>=
   function var_entry_is_locked (var, force) result (locked)
     logical :: locked
     type(var_entry_t), intent(in) :: var
     logical, intent(in), optional :: force
     if (present (force)) then
        if (force) then
           locked = .false.;  return
        end if
     end if
     locked = var%is_locked
   end function var_entry_is_locked
 
 @ %def var_entry_is_locked
 @ Return true if the variable is intrinsic
 <<Variables: procedures>>=
   function var_entry_is_intrinsic (var) result (flag)
     logical :: flag
     type(var_entry_t), intent(in) :: var
     flag = var%is_intrinsic
   end function var_entry_is_intrinsic
 
 @ %def var_entry_is_intrinsic
 @ Return components
 <<Variables: procedures>>=
   function var_entry_is_known (var) result (flag)
     logical :: flag
     type(var_entry_t), intent(in) :: var
     flag = var%is_known
   end function var_entry_is_known
 
   function var_entry_get_lval (var) result (lval)
     logical :: lval
     type(var_entry_t), intent(in) :: var
     lval = var%lval
   end function var_entry_get_lval
 
   function var_entry_get_ival (var) result (ival)
     integer :: ival
     type(var_entry_t), intent(in) :: var
     ival = var%ival
   end function var_entry_get_ival
 
   function var_entry_get_rval (var) result (rval)
     real(default) :: rval
     type(var_entry_t), intent(in) :: var
     rval = var%rval
   end function var_entry_get_rval
 
   function var_entry_get_cval (var) result (cval)
     complex(default) :: cval
     type(var_entry_t), intent(in) :: var
     cval = var%cval
   end function var_entry_get_cval
 
   function var_entry_get_aval (var) result (aval)
     type(pdg_array_t) :: aval
     type(var_entry_t), intent(in) :: var
     aval = var%aval
   end function var_entry_get_aval
 
   function var_entry_get_pval (var) result (pval)
     type(subevt_t) :: pval
     type(var_entry_t), intent(in) :: var
     pval = var%pval
   end function var_entry_get_pval
 
   function var_entry_get_sval (var) result (sval)
     type(string_t) :: sval
     type(var_entry_t), intent(in) :: var
     sval = var%sval
   end function var_entry_get_sval
 
 @ %def var_entry_get_lval
 @ %def var_entry_get_ival
 @ %def var_entry_get_rval
 @ %def var_entry_get_cval
 @ %def var_entry_get_aval
 @ %def var_entry_get_pval
 @ %def var_entry_get_sval
 @ Return pointers to components.
 <<Variables: procedures>>=
   function var_entry_get_known_ptr (var) result (ptr)
     logical, pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%is_known
   end function var_entry_get_known_ptr
 
   function var_entry_get_lval_ptr (var) result (ptr)
     logical, pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%lval
   end function var_entry_get_lval_ptr
 
   function var_entry_get_ival_ptr (var) result (ptr)
     integer, pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%ival
   end function var_entry_get_ival_ptr
 
   function var_entry_get_rval_ptr (var) result (ptr)
     real(default), pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%rval
   end function var_entry_get_rval_ptr
 
   function var_entry_get_cval_ptr (var) result (ptr)
     complex(default), pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%cval
   end function var_entry_get_cval_ptr
 
   function var_entry_get_pval_ptr (var) result (ptr)
     type(subevt_t), pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%pval
   end function var_entry_get_pval_ptr
 
   function var_entry_get_aval_ptr (var) result (ptr)
     type(pdg_array_t), pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%aval
   end function var_entry_get_aval_ptr
 
   function var_entry_get_sval_ptr (var) result (ptr)
     type(string_t), pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%sval
   end function var_entry_get_sval_ptr
 
 @ %def var_entry_get_known_ptr
 @ %def var_entry_get_lval_ptr var_entry_get_ival_ptr var_entry_get_rval_ptr
 @ %def var_entry_get_cval_ptr var_entry_get_aval_ptr var_entry_get_pval_ptr
 @ %def var_entry_get_sval_ptr
 @ Furthermore,
 <<Variables: procedures>>=
   function var_entry_get_prt1_ptr (var) result (ptr)
     type(prt_t), pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%prt1
   end function var_entry_get_prt1_ptr
 
   function var_entry_get_prt2_ptr (var) result (ptr)
     type(prt_t), pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%prt2
   end function var_entry_get_prt2_ptr
 
 @ %def var_entry_get_prt1_ptr
 @ %def var_entry_get_prt2_ptr
 @ Subroutines might be safer than functions for procedure pointer transfer
 (there was a nagfor bug).
 <<Variables: procedures>>=
   subroutine var_entry_assign_obs1_int_ptr (ptr, var)
     procedure(obs_unary_int), pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%obs1_int
   end subroutine var_entry_assign_obs1_int_ptr
 
   subroutine var_entry_assign_obs1_real_ptr (ptr, var)
     procedure(obs_unary_real), pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%obs1_real
   end subroutine var_entry_assign_obs1_real_ptr
 
   subroutine var_entry_assign_obs2_int_ptr (ptr, var)
     procedure(obs_binary_int), pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%obs2_int
   end subroutine var_entry_assign_obs2_int_ptr
 
   subroutine var_entry_assign_obs2_real_ptr (ptr, var)
     procedure(obs_binary_real), pointer :: ptr
     type(var_entry_t), intent(in), target :: var
     ptr => var%obs2_real
   end subroutine var_entry_assign_obs2_real_ptr
 
 @ %def var_entry_assign_obs1_int_ptr var_entry_assign_obs1_real_ptr
 @ %def var_entry_assign_obs2_int_ptr var_entry_assign_obs2_real_ptr
 @
 \subsection{Setting values}
 Undefine the value.
 <<Variables: procedures>>=
   subroutine var_entry_clear_value (var)
     type(var_entry_t), intent(inout) :: var
     var%is_known = .false.
   end subroutine var_entry_clear_value
 
 @ %def var_entry_clear_value
 <<Variables: procedures>>=
   recursive subroutine var_entry_set_log &
        (var, lval, is_known, verbose, model_name)
     type(var_entry_t), intent(inout) :: var
     logical, intent(in) :: lval
     logical, intent(in) :: is_known
     logical, intent(in), optional :: verbose
     type(string_t), intent(in), optional :: model_name
     integer :: u
     u = logfile_unit ()
     var%lval = lval
     var%is_known = is_known
     var%is_defined = .true.
     if (present (verbose)) then
        if (verbose) then
           call var_entry_write (var, model_name=model_name)
           call var_entry_write (var, model_name=model_name, unit=u)
           if (u >= 0) flush (u)
        end if
     end if
   end subroutine var_entry_set_log
 
   recursive subroutine var_entry_set_int &
        (var, ival, is_known, verbose, model_name)
     type(var_entry_t), intent(inout) :: var
     integer, intent(in) :: ival
     logical, intent(in) :: is_known
     logical, intent(in), optional :: verbose
     type(string_t), intent(in), optional :: model_name
     integer :: u
     u = logfile_unit ()
     var%ival = ival
     var%is_known = is_known
     var%is_defined = .true.
     if (present (verbose)) then
        if (verbose) then
           call var_entry_write (var, model_name=model_name)
           call var_entry_write (var, model_name=model_name, unit=u)
           if (u >= 0) flush (u)
        end if
     end if
   end subroutine var_entry_set_int
 
   recursive subroutine var_entry_set_real &
        (var, rval, is_known, verbose, model_name, pacified)
     type(var_entry_t), intent(inout) :: var
     real(default), intent(in) :: rval
     logical, intent(in) :: is_known
     logical, intent(in), optional :: verbose, pacified
     type(string_t), intent(in), optional :: model_name
     integer :: u
     u = logfile_unit ()
     var%rval = rval
     var%is_known = is_known
     var%is_defined = .true.
     if (present (verbose)) then
        if (verbose) then
           call var_entry_write &
                (var, model_name=model_name, pacified = pacified)
           call var_entry_write &
                (var, model_name=model_name, unit=u, pacified = pacified)
           if (u >= 0) flush (u)
        end if
     end if
   end subroutine var_entry_set_real
 
   recursive subroutine var_entry_set_cmplx &
        (var, cval, is_known, verbose, model_name, pacified)
     type(var_entry_t), intent(inout) :: var
     complex(default), intent(in) :: cval
     logical, intent(in) :: is_known
     logical, intent(in), optional :: verbose, pacified
     type(string_t), intent(in), optional :: model_name
     integer :: u
     u = logfile_unit ()
     var%cval = cval
     var%is_known = is_known
     var%is_defined = .true.
     if (present (verbose)) then
        if (verbose) then
           call var_entry_write &
                (var, model_name=model_name, pacified = pacified)
           call var_entry_write &
                (var, model_name=model_name, unit=u, pacified = pacified)
           if (u >= 0) flush (u)
        end if
     end if
   end subroutine var_entry_set_cmplx
 
   recursive subroutine var_entry_set_pdg_array &
        (var, aval, is_known, verbose, model_name)
     type(var_entry_t), intent(inout) :: var
     type(pdg_array_t), intent(in) :: aval
     logical, intent(in) :: is_known
     logical, intent(in), optional :: verbose
     type(string_t), intent(in), optional :: model_name
     integer :: u
     u = logfile_unit ()
     var%aval = aval
     var%is_known = is_known
     var%is_defined = .true.
     if (present (verbose)) then
        if (verbose) then
           call var_entry_write (var, model_name=model_name)
           call var_entry_write (var, model_name=model_name, unit=u)
           if (u >= 0) flush (u)
        end if
     end if
   end subroutine var_entry_set_pdg_array
 
   recursive subroutine var_entry_set_subevt &
        (var, pval, is_known, verbose, model_name)
     type(var_entry_t), intent(inout) :: var
     type(subevt_t), intent(in) :: pval
     logical, intent(in) :: is_known
     logical, intent(in), optional :: verbose
     type(string_t), intent(in), optional :: model_name
     integer :: u
     u = logfile_unit ()
     var%pval = pval
     var%is_known = is_known
     var%is_defined = .true.
     if (present (verbose)) then
        if (verbose) then
           call var_entry_write (var, model_name=model_name)
           call var_entry_write (var, model_name=model_name, unit=u)
           if (u >= 0) flush (u)
        end if
     end if
   end subroutine var_entry_set_subevt
 
   recursive subroutine var_entry_set_string &
        (var, sval, is_known, verbose, model_name)
     type(var_entry_t), intent(inout) :: var
     type(string_t), intent(in) :: sval
     logical, intent(in) :: is_known
     logical, intent(in), optional :: verbose
     type(string_t), intent(in), optional :: model_name
     integer :: u
     u = logfile_unit ()
     var%sval = sval
     var%is_known = is_known
     var%is_defined = .true.
     if (present (verbose)) then
        if (verbose) then
           call var_entry_write (var, model_name=model_name)
           call var_entry_write (var, model_name=model_name, unit=u)
           if (u >= 0) flush (u)
        end if
     end if
   end subroutine var_entry_set_string
 
 @ %def var_entry_set_log
 @ %def var_entry_set_int
 @ %def var_entry_set_real
 @ %def var_entry_set_cmplx
 @ %def var_entry_set_pdg_array
 @ %def var_entry_set_subevt
 @ %def var_entry_set_string
 @
 <<Variables: public>>=
   public :: var_entry_set_description
 <<Variables: procedures>>=
   pure subroutine var_entry_set_description (var_entry, description)
     type(var_entry_t), intent(inout) :: var_entry
     type(string_t), intent(in) :: description
     var_entry%description = description
   end subroutine var_entry_set_description
 
 @ %def var_entry_set_description
 @
 \subsection{Copies and pointer variables}
 Initialize an entry with a copy of an existing variable entry.  The
 copy is physically allocated with the same type as the original.
 <<Variables: procedures>>=
   subroutine var_entry_init_copy (var, original, user)
     type(var_entry_t), intent(out) :: var
     type(var_entry_t), intent(in), target :: original
     logical, intent(in), optional :: user
     type(string_t) :: name
     logical :: intrinsic
     name = var_entry_get_name (original)
     intrinsic = original%is_intrinsic
     select case (original%type)
     case (V_LOG)
        call var_entry_init_log (var, name, intrinsic=intrinsic, user=user)
     case (V_INT)
        call var_entry_init_int (var, name, intrinsic=intrinsic, user=user)
     case (V_REAL)
        call var_entry_init_real (var, name, intrinsic=intrinsic, user=user)
     case (V_CMPLX)
        call var_entry_init_cmplx (var, name, intrinsic=intrinsic, user=user)
     case (V_SEV)
        call var_entry_init_subevt (var, name, intrinsic=intrinsic, user=user)
     case (V_PDG)
        call var_entry_init_pdg_array (var, name, intrinsic=intrinsic, user=user)
     case (V_STR)
        call var_entry_init_string (var, name, intrinsic=intrinsic, user=user)
     end select
   end subroutine var_entry_init_copy
 
 @ %def var_entry_init_copy
 @ Copy the value of an entry.  The target variable entry must be initialized
 correctly.
 <<Variables: procedures>>=
   subroutine var_entry_copy_value (var, original)
     type(var_entry_t), intent(inout) :: var
     type(var_entry_t), intent(in), target :: original
     if (var_entry_is_known (original)) then
        select case (original%type)
        case (V_LOG)
           call var_entry_set_log (var, var_entry_get_lval (original), .true.)
        case (V_INT)
           call var_entry_set_int (var, var_entry_get_ival (original), .true.)
        case (V_REAL)
           call var_entry_set_real (var, var_entry_get_rval (original), .true.)
        case (V_CMPLX)
           call var_entry_set_cmplx (var, var_entry_get_cval (original), .true.)
        case (V_SEV)
           call var_entry_set_subevt (var, var_entry_get_pval (original), .true.)
        case (V_PDG)
           call var_entry_set_pdg_array (var, var_entry_get_aval (original), .true.)
        case (V_STR)
           call var_entry_set_string (var, var_entry_get_sval (original), .true.)
        end select
     else
        call var_entry_clear (var)
     end if
   end subroutine var_entry_copy_value
 
 @ %def var_entry_copy_value
 @
 \subsection{Variable lists}
 \subsubsection{The type}
 Variable lists can be linked together.  No initializer needed.
 They are deleted separately.
 <<Variables: public>>=
   public :: var_list_t
 <<Variables: types>>=
   type, extends (vars_t) :: var_list_t
      private
      type(var_entry_t), pointer :: first => null ()
      type(var_entry_t), pointer :: last => null ()
      type(var_list_t), pointer :: next => null ()
    contains
    <<Variables: var list: TBP>>
   end type var_list_t
 
 @ %def var_list_t
 @
 \subsubsection{Constructors}
 Implementation of the [[link]] deferred method.  The implementation
 restricts itself to var lists of the same type.  We might need to
 relax this constraint.
 <<Variables: var list: TBP>>=
   procedure :: link => var_list_link
 <<Variables: procedures>>=
   subroutine var_list_link (vars, target_vars)
     class(var_list_t), intent(inout) :: vars
     class(vars_t), intent(in), target :: target_vars
     select type (target_vars)
     type is (var_list_t)
        vars%next => target_vars
     class default
        call msg_bug ("var_list_link: unsupported target type")
     end select
   end subroutine var_list_link
 
 @ %def var_list_link
 @ Append a new entry to an existing list.
 <<Variables: procedures>>=
   subroutine var_list_append (var_list, var, verbose)
     type(var_list_t), intent(inout), target :: var_list
     type(var_entry_t), intent(inout), target :: var
     logical, intent(in), optional :: verbose
     if (associated (var_list%last)) then
        var%previous => var_list%last
        var_list%last%next => var
     else
        var%previous => null ()
        var_list%first => var
     end if
     var_list%last => var
     if (present (verbose)) then
        if (verbose)  call var_entry_write (var)
     end if
   end subroutine var_list_append
 
 @ %def var_list_append
 @ Sort a list.
 <<Variables: var list: TBP>>=
   procedure :: sort => var_list_sort
 <<Variables: procedures>>=
   subroutine var_list_sort (var_list)
     class(var_list_t), intent(inout) :: var_list
     type(var_entry_t), pointer :: var, previous
     if (associated (var_list%first)) then
        var => var_list%first
        do while (associated (var))
           previous => var%previous
           do while (associated (previous))
              if (larger_var (previous, var)) then
                 call var_list%swap_with_next (previous)
              end if
              previous => previous%previous
           end do
           var => var%next
        end do
     end if
   end subroutine var_list_sort
 
 @ %def var_list_sort
 @
 <<Variables: procedures>>=
   pure function larger_var (var1, var2) result (larger)
     logical :: larger
     type(var_entry_t), intent(in) :: var1, var2
     type(string_t) :: str1, str2
     str1 = replace (var1%name, "?", "")
     str1 = replace (str1, "$", "")
     str2 = replace (var2%name, "?", "")
     str2 = replace (str2, "$", "")
     larger = str1 > str2
   end function larger_var
 
 @ %def larger_var
 @
 <<Variables: var list: TBP>>=
   procedure :: get_previous => var_list_get_previous
 <<Variables: procedures>>=
   function var_list_get_previous (var_list, var_entry) result (previous)
     type(var_entry_t), pointer :: previous
     class(var_list_t), intent(in) :: var_list
     type(var_entry_t), intent(in) :: var_entry
     previous => var_list%first
     if (previous%name == var_entry%name) then
        previous => null ()
     else
        do while (associated (previous))
           if (previous%next%name == var_entry%name) exit
           previous => previous%next
        end do
     end if
   end function var_list_get_previous
 
 @ %def var_list_get_previous
 @
 <<Variables: var list: TBP>>=
   procedure :: swap_with_next => var_list_swap_with_next
 <<Variables: procedures>>=
   subroutine var_list_swap_with_next (var_list, var_entry)
     class(var_list_t), intent(inout) :: var_list
     type(var_entry_t), intent(in) :: var_entry
     type(var_entry_t), pointer :: previous, this, next, next_next
     previous => var_list%get_previous (var_entry)
     if (.not. associated (previous)) then
        this => var_list%first
     else
        this => previous%next
     end if
     next => this%next
     next_next => next%next
     if (associated (previous)) then
        previous%next => next
        next%previous => previous
     else
        var_list%first => next
        next%previous => null ()
     end if
     this%next => next_next
     if (associated (next_next)) then
        next_next%previous => this
     end if
     next%next => this
     this%previous => next
     if (.not. associated (next%next)) then
        var_list%last => next
     end if
   end subroutine var_list_swap_with_next
 
 @ %def var_list_swap_with_next
 @ Public methods for expanding the variable list (as subroutines)
 <<Variables: var list: TBP>>=
   generic :: append_log => var_list_append_log_s, var_list_append_log_c
   procedure, private :: var_list_append_log_s
   procedure, private :: var_list_append_log_c
   generic :: append_int => var_list_append_int_s, var_list_append_int_c
   procedure, private :: var_list_append_int_s
   procedure, private :: var_list_append_int_c
   generic :: append_real => var_list_append_real_s, var_list_append_real_c
   procedure, private :: var_list_append_real_s
   procedure, private :: var_list_append_real_c
   generic :: append_cmplx => var_list_append_cmplx_s, var_list_append_cmplx_c
   procedure, private :: var_list_append_cmplx_s
   procedure, private :: var_list_append_cmplx_c
   generic :: append_subevt => var_list_append_subevt_s, var_list_append_subevt_c
   procedure, private :: var_list_append_subevt_s
   procedure, private :: var_list_append_subevt_c
   generic :: append_pdg_array => var_list_append_pdg_array_s, var_list_append_pdg_array_c
   procedure, private :: var_list_append_pdg_array_s
   procedure, private :: var_list_append_pdg_array_c
   generic :: append_string => var_list_append_string_s, var_list_append_string_c
   procedure, private :: var_list_append_string_s
   procedure, private :: var_list_append_string_c
 <<Variables: public>>=
   public :: var_list_append_log
   public :: var_list_append_int
   public :: var_list_append_real
   public :: var_list_append_cmplx
   public :: var_list_append_subevt
   public :: var_list_append_pdg_array
   public :: var_list_append_string
 <<Variables: interfaces>>=
   interface var_list_append_log
      module procedure var_list_append_log_s
      module procedure var_list_append_log_c
   end interface
   interface var_list_append_int
      module procedure var_list_append_int_s
      module procedure var_list_append_int_c
   end interface
   interface var_list_append_real
      module procedure var_list_append_real_s
      module procedure var_list_append_real_c
   end interface
   interface var_list_append_cmplx
      module procedure var_list_append_cmplx_s
      module procedure var_list_append_cmplx_c
   end interface
   interface var_list_append_subevt
      module procedure var_list_append_subevt_s
      module procedure var_list_append_subevt_c
   end interface
   interface var_list_append_pdg_array
      module procedure var_list_append_pdg_array_s
      module procedure var_list_append_pdg_array_c
   end interface
   interface var_list_append_string
      module procedure var_list_append_string_s
      module procedure var_list_append_string_c
   end interface
 <<Variables: procedures>>=
   subroutine var_list_append_log_s &
        (var_list, name, lval, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     logical, intent(in), optional :: lval
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_log (var, name, lval, intrinsic, user)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_log_s
 
   subroutine var_list_append_int_s &
        (var_list, name, ival, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     integer, intent(in), optional :: ival
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_int (var, name, ival, intrinsic, user)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_int_s
 
   subroutine var_list_append_real_s &
        (var_list, name, rval, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     real(default), intent(in), optional :: rval
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_real (var, name, rval, intrinsic, user)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_real_s
 
   subroutine var_list_append_cmplx_s &
        (var_list, name, cval, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     complex(default), intent(in), optional :: cval
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_cmplx (var, name, cval, intrinsic, user)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_cmplx_s
 
   subroutine var_list_append_subevt_s &
        (var_list, name, pval, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     type(subevt_t), intent(in), optional :: pval
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_subevt (var, name, pval, intrinsic, user)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_subevt_s
 
   subroutine var_list_append_pdg_array_s &
        (var_list, name, aval, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     type(pdg_array_t), intent(in), optional :: aval
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_pdg_array (var, name, aval, intrinsic, user)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_pdg_array_s
 
   subroutine var_list_append_string_s &
        (var_list, name, sval, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     type(string_t), intent(in), optional :: sval
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_string (var, name, sval, intrinsic, user)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_string_s
 
   subroutine var_list_append_log_c &
        (var_list, name, lval, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     character(*), intent(in) :: name
     logical, intent(in), optional :: lval
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     call var_list_append_log_s &
          (var_list, var_str (name), lval, locked, verbose, &
          intrinsic, user, description)
   end subroutine var_list_append_log_c
 
   subroutine var_list_append_int_c &
        (var_list, name, ival, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     character(*), intent(in) :: name
     integer, intent(in), optional :: ival
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     call var_list_append_int_s &
          (var_list, var_str (name), ival, locked, verbose, &
          intrinsic, user, description)
   end subroutine var_list_append_int_c
 
   subroutine var_list_append_real_c &
        (var_list, name, rval, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     character(*), intent(in) :: name
     real(default), intent(in), optional :: rval
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     call var_list_append_real_s &
          (var_list, var_str (name), rval, locked, verbose, &
          intrinsic, user, description)
   end subroutine var_list_append_real_c
 
   subroutine var_list_append_cmplx_c &
        (var_list, name, cval, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     character(*), intent(in) :: name
     complex(default), intent(in), optional :: cval
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     call var_list_append_cmplx_s &
          (var_list, var_str (name), cval, locked, verbose, &
          intrinsic, user, description)
   end subroutine var_list_append_cmplx_c
 
   subroutine var_list_append_subevt_c &
        (var_list, name, pval, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     character(*), intent(in) :: name
     type(subevt_t), intent(in), optional :: pval
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     call var_list_append_subevt_s &
          (var_list, var_str (name), pval, locked, verbose, &
          intrinsic, user, description)
   end subroutine var_list_append_subevt_c
 
   subroutine var_list_append_pdg_array_c &
        (var_list, name, aval, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     character(*), intent(in) :: name
     type(pdg_array_t), intent(in), optional :: aval
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     call var_list_append_pdg_array_s &
          (var_list, var_str (name), aval, locked, verbose, &
          intrinsic, user, description)
   end subroutine var_list_append_pdg_array_c
 
   subroutine var_list_append_string_c &
        (var_list, name, sval, locked, verbose, intrinsic, user, description)
     class(var_list_t), intent(inout) :: var_list
     character(*), intent(in) :: name
     character(*), intent(in), optional :: sval
     logical, intent(in), optional :: locked, verbose, intrinsic, user
     type(string_t), intent(in), optional :: description
     if (present (sval)) then
        call var_list_append_string_s &
             (var_list, var_str (name), var_str (sval), &
             locked, verbose, intrinsic, user, description)
     else
        call var_list_append_string_s &
             (var_list, var_str (name), &
             locked=locked, verbose=verbose, intrinsic=intrinsic, &
             user=user, description=description)
     end if
   end subroutine var_list_append_string_c
 
 @ %def var_list_append_log
 @ %def var_list_append_int
 @ %def var_list_append_real
 @ %def var_list_append_cmplx
 @ %def var_list_append_subevt
 @ %def var_list_append_pdg_array
 @ %def var_list_append_string
 <<Variables: public>>=
   public :: var_list_append_log_ptr
   public :: var_list_append_int_ptr
   public :: var_list_append_real_ptr
   public :: var_list_append_cmplx_ptr
   public :: var_list_append_pdg_array_ptr
   public :: var_list_append_subevt_ptr
   public :: var_list_append_string_ptr
 <<Variables: var list: TBP>>=
   procedure :: append_log_ptr => var_list_append_log_ptr
   procedure :: append_int_ptr => var_list_append_int_ptr
   procedure :: append_real_ptr => var_list_append_real_ptr
   procedure :: append_cmplx_ptr => var_list_append_cmplx_ptr
   procedure :: append_pdg_array_ptr => var_list_append_pdg_array_ptr
   procedure :: append_subevt_ptr => var_list_append_subevt_ptr
   procedure :: append_string_ptr => var_list_append_string_ptr
 <<Variables: procedures>>=
   subroutine var_list_append_log_ptr &
        (var_list, name, lval, is_known, locked, verbose, intrinsic, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     logical, intent(in), target :: lval
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: locked, verbose, intrinsic
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_log_ptr (var, name, lval, is_known, intrinsic)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_log_ptr
 
   subroutine var_list_append_int_ptr &
        (var_list, name, ival, is_known, locked, verbose, intrinsic, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     integer, intent(in), target :: ival
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: locked, verbose, intrinsic
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_int_ptr (var, name, ival, is_known, intrinsic)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_int_ptr
 
   subroutine var_list_append_real_ptr &
        (var_list, name, rval, is_known, locked, verbose, intrinsic, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     real(default), intent(in), target :: rval
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: locked, verbose, intrinsic
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_real_ptr (var, name, rval, is_known, intrinsic)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_real_ptr
 
   subroutine var_list_append_cmplx_ptr &
        (var_list, name, cval, is_known, locked, verbose, intrinsic, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     complex(default), intent(in), target :: cval
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: locked, verbose, intrinsic
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_cmplx_ptr (var, name, cval, is_known, intrinsic)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_cmplx_ptr
 
   subroutine var_list_append_pdg_array_ptr &
        (var_list, name, aval, is_known, locked, verbose, intrinsic, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     type(pdg_array_t), intent(in), target :: aval
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: locked, verbose, intrinsic
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_pdg_array_ptr (var, name, aval, is_known, intrinsic)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_pdg_array_ptr
 
   subroutine var_list_append_subevt_ptr &
        (var_list, name, pval, is_known, locked, verbose, intrinsic, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     type(subevt_t), intent(in), target :: pval
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: locked, verbose, intrinsic
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_subevt_ptr (var, name, pval, is_known, intrinsic)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_subevt_ptr
 
   subroutine var_list_append_string_ptr &
        (var_list, name, sval, is_known, locked, verbose, intrinsic, description)
     class(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     type(string_t), intent(in), target :: sval
     logical, intent(in), target :: is_known
     logical, intent(in), optional :: locked, verbose, intrinsic
     type(string_t), intent(in), optional :: description
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_string_ptr (var, name, sval, is_known, intrinsic)
     if (present (description))  call var_entry_set_description (var, description)
     if (present (locked))  call var_entry_lock (var, locked)
     call var_list_append (var_list, var, verbose)
   end subroutine var_list_append_string_ptr
 
 @ %def var_list_append_log_ptr
 @ %def var_list_append_int_ptr
 @ %def var_list_append_real_ptr
 @ %def var_list_append_cmplx_ptr
 @ %def var_list_append_pdg_array_ptr
 @ %def var_list_append_subevt_ptr
 @
 \subsubsection{Finalizer}
 Finalize, delete the list entry by entry.  The link itself is kept
 intact.  Follow link and delete recursively only if requested
 explicitly.
 <<Variables: var list: TBP>>=
   procedure :: final => var_list_final
 <<Variables: procedures>>=
   recursive subroutine var_list_final (vars, follow_link)
     class(var_list_t), intent(inout) :: vars
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     vars%last => null ()
     do while (associated (vars%first))
        var => vars%first
        vars%first => var%next
        call var_entry_final (var)
        deallocate (var)
     end do
     if (present (follow_link)) then
        if (follow_link) then
           if (associated (vars%next)) then
              call vars%next%final (follow_link)
              deallocate (vars%next)
           end if
        end if
     end if
   end subroutine var_list_final
 
 @ %def var_list_final
 @
 \subsubsection{Output}
 Show variable list with precise control over options.  E.g.,
 show only variables of a certain type.
 
 Many options, thus not an ordinary [[write]] method.
 <<Variables: public>>=
   public :: var_list_write
 <<Variables: var list: TBP>>=
   procedure :: write => var_list_write
 <<Variables: procedures>>=
   recursive subroutine var_list_write &
        (var_list, unit, follow_link, only_type, prefix, model_name, &
         intrinsic, pacified, descriptions, ascii_output)
     class(var_list_t), intent(in), target :: var_list
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: follow_link
     integer, intent(in), optional :: only_type
     character(*), intent(in), optional :: prefix
     type(string_t), intent(in), optional :: model_name
     logical, intent(in), optional :: intrinsic
     logical, intent(in), optional :: pacified
     logical, intent(in), optional :: descriptions
     logical, intent(in), optional :: ascii_output
     type(var_entry_t), pointer :: var
     integer :: u, length
     logical :: write_this, write_next
     u = given_output_unit (unit);  if (u < 0)  return
     if (present (prefix))  length = len (prefix)
     var => var_list%first
     if (associated (var)) then
        do while (associated (var))
           if (present (only_type)) then
              write_this = only_type == var%type
           else
              write_this = .true.
           end if
           if (write_this .and. present (prefix)) then
              if (prefix /= extract (var%name, 1, length)) &
                   write_this = .false.
           end if
           if (write_this) then
              call var_entry_write &
                   (var, unit, model_name=model_name, &
                    intrinsic=intrinsic, pacified=pacified, &
                    descriptions=descriptions, ascii_output=ascii_output)
           end if
           var => var%next
        end do
     end if
     if (present (follow_link)) then
        write_next = follow_link .and. associated (var_list%next)
     else
        write_next = associated (var_list%next)
     end if
     if (write_next) then
        call var_list_write (var_list%next, &
             unit, follow_link, only_type, prefix, model_name, &
             intrinsic, pacified)
     end if
   end subroutine var_list_write
 
 @ %def var_list_write
 @ Write only a certain variable.
 <<Variables: public>>=
   public :: var_list_write_var
 <<Variables: var list: TBP>>=
   procedure :: write_var => var_list_write_var
 <<Variables: procedures>>=
   recursive subroutine var_list_write_var &
        (var_list, name, unit, type, follow_link, &
        model_name, pacified, defined, descriptions, ascii_output)
     class(var_list_t), intent(in), target :: var_list
     type(string_t), intent(in) :: name
     integer, intent(in), optional :: unit
     integer, intent(in), optional :: type
     logical, intent(in), optional :: follow_link
     type(string_t), intent(in), optional :: model_name
     logical, intent(in), optional :: pacified
     logical, intent(in), optional :: defined
     logical, intent(in), optional :: descriptions
     logical, intent(in), optional :: ascii_output
     type(var_entry_t), pointer :: var
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     var => var_list_get_var_ptr &
          (var_list, name, type, follow_link=follow_link, defined=defined)
     if (associated (var)) then
        call var_entry_write &
             (var, unit, model_name = model_name, &
             pacified = pacified, &
             descriptions=descriptions, ascii_output=ascii_output)
     else
        write (u, "(A)")  char (name) // " = [undefined]"
     end if
   end subroutine var_list_write_var
 
 @ %def var_list_write_var
 @
 \subsection{Tools}
 Return a pointer to the variable list linked to by the current one.
 <<Variables: procedures>>=
   function var_list_get_next_ptr (var_list) result (next_ptr)
     type(var_list_t), pointer :: next_ptr
     type(var_list_t), intent(in) :: var_list
     next_ptr => var_list%next
   end function var_list_get_next_ptr
 
 @ %def var_list_get_next_ptr
 @ Used by [[eval_trees]]:
 Return a pointer to the variable with the requested name.  If no such
 name exists, return a null pointer.  In that case, try the next list
 if present, unless [[follow_link]] is unset.  If [[defined]] is set, ignore
 entries that exist but are undefined.
 <<Variables: public>>=
   public :: var_list_get_var_ptr
 <<Variables: procedures>>=
   recursive function var_list_get_var_ptr &
        (var_list, name, type, follow_link, defined) result (var)
     type(var_entry_t), pointer :: var
     type(var_list_t), intent(in), target :: var_list
     type(string_t), intent(in) :: name
     integer, intent(in), optional :: type
     logical, intent(in), optional :: follow_link, defined
     logical :: ignore_undef, search_next
     ignore_undef = .true.;  if (present (defined))  ignore_undef = .not. defined
     var => var_list%first
     if (present (type)) then
        do while (associated (var))
           if (var%type == type) then
              if (var%name == name) then
                 if (ignore_undef .or. var%is_defined)  return
              end if
           end if
           var => var%next
        end do
     else
        do while (associated (var))
           if (var%name == name) then
              if (ignore_undef .or. var%is_defined)  return
           end if
           var => var%next
        end do
     end if
     search_next = associated (var_list%next)
     if (present (follow_link)) &
          search_next = search_next .and. follow_link
     if (search_next) &
          var => var_list_get_var_ptr &
               (var_list%next, name, type, defined=defined)
   end function var_list_get_var_ptr
 
 @ %def var_list_get_var_ptr
 @ Return the variable type
 <<Variables: var list: TBP>>=
   procedure :: get_type => var_list_get_type
 <<Variables: procedures>>=
   function var_list_get_type (var_list, name, follow_link) result (type)
     class(var_list_t), intent(in), target :: var_list
     type(string_t), intent(in) :: name
     logical, intent(in), optional :: follow_link
     integer :: type
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, follow_link=follow_link)
     if (associated (var)) then
        type = var%type
     else
        type = V_NONE
     end if
   end function var_list_get_type
 
 @ %def var_list_get_type
 @ Return true if the variable exists in the current list.
 <<Variables: var list: TBP>>=
   procedure :: contains => var_list_exists
 <<Variables: procedures>>=
   function var_list_exists (vars, name, follow_link) result (lval)
     logical :: lval
     type(string_t), intent(in) :: name
     class(var_list_t), intent(in) :: vars
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (vars, name, follow_link=follow_link)
     lval = associated (var)
   end function var_list_exists
 
 @ %def var_list_exists
 @ Return true if the variable is declared as intrinsic.  (This is not a
 property of the abstract [[vars_t]] type, and therefore the method is
 not inherited.)
 <<Variables: var list: TBP>>=
   procedure :: is_intrinsic => var_list_is_intrinsic
 <<Variables: procedures>>=
   function var_list_is_intrinsic (vars, name, follow_link) result (lval)
     logical :: lval
     type(string_t), intent(in) :: name
     class(var_list_t), intent(in) :: vars
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (vars, name, follow_link=follow_link)
     if (associated (var)) then
        lval = var%is_intrinsic
     else
        lval = .false.
     end if
   end function var_list_is_intrinsic
 
 @ %def var_list_is_intrinsic
 @ Return true if the value is known.
 <<Variables: var list: TBP>>=
   procedure :: is_known => var_list_is_known
 <<Variables: procedures>>=
   function var_list_is_known (vars, name, follow_link) result (lval)
     logical :: lval
     type(string_t), intent(in) :: name
     class(var_list_t), intent(in) :: vars
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (vars, name, follow_link=follow_link)
     if (associated (var)) then
        lval = var%is_known
     else
        lval = .false.
     end if
   end function var_list_is_known
 
 @ %def var_list_is_known
 @ Return true if the value is locked.  (This is not a
 property of the abstract [[vars_t]] type, and therefore the method is
 not inherited.)
 <<Variables: var list: TBP>>=
   procedure :: is_locked => var_list_is_locked
 <<Variables: procedures>>=
   function var_list_is_locked (vars, name, follow_link) result (lval)
     logical :: lval
     type(string_t), intent(in) :: name
     class(var_list_t), intent(in) :: vars
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (vars, name, follow_link=follow_link)
     if (associated (var)) then
        lval = var_entry_is_locked (var)
     else
        lval = .false.
     end if
   end function var_list_is_locked
 
 @ %def var_list_is_locked
 @ Return several properties at once.
 <<Variables: var list: TBP>>=
   procedure :: get_var_properties => var_list_get_var_properties
 <<Variables: procedures>>=
   subroutine var_list_get_var_properties (vars, name, req_type, follow_link, &
        type, is_defined, is_known, is_locked)
     class(var_list_t), intent(in) :: vars
     type(string_t), intent(in) :: name
     integer, intent(in), optional :: req_type
     logical, intent(in), optional :: follow_link
     integer, intent(out), optional :: type
     logical, intent(out), optional :: is_defined, is_known, is_locked
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr &
          (vars, name, type=req_type, follow_link=follow_link)
     if (associated (var)) then
        if (present (type))  type = var_entry_get_type (var)
        if (present (is_defined))  is_defined = var_entry_is_defined (var)
        if (present (is_known))  is_known = var_entry_is_known (var)
        if (present (is_locked))  is_locked = var_entry_is_locked (var)
     else
        if (present (type))  type = V_NONE
        if (present (is_defined))  is_defined = .false.
        if (present (is_known))  is_known = .false.
        if (present (is_locked))  is_locked = .false.
     end if
   end subroutine var_list_get_var_properties
 
 @ %def var_list_get_var_properties
 @ Return the value, assuming that the type is correct.  We consider only
 variable entries that have been [[defined]].
 
 For convenience, allow both variable and fixed-length (literal) strings.
 <<Variables: var list: TBP>>=
   procedure :: get_lval => var_list_get_lval
   procedure :: get_ival => var_list_get_ival
   procedure :: get_rval => var_list_get_rval
   procedure :: get_cval => var_list_get_cval
   procedure :: get_pval => var_list_get_pval
   procedure :: get_aval => var_list_get_aval
   procedure :: get_sval => var_list_get_sval
 <<Variables: procedures>>=
   function var_list_get_lval (vars, name, follow_link) result (lval)
     logical :: lval
     type(string_t), intent(in) :: name
     class(var_list_t), intent(in) :: vars
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr &
          (vars, name, V_LOG, follow_link, defined=.true.)
     if (associated (var)) then
        if (var_has_value (var)) then
           lval = var%lval
        else
           lval = .false.
        end if
     else
        lval = .false.
     end if
   end function var_list_get_lval
 
   function var_list_get_ival (vars, name, follow_link) result (ival)
     integer :: ival
     type(string_t), intent(in) :: name
     class(var_list_t), intent(in) :: vars
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr &
          (vars, name, V_INT, follow_link, defined=.true.)
     if (associated (var)) then
        if (var_has_value (var)) then
           ival = var%ival
        else
           ival = 0
        end if
     else
        ival = 0
     end if
   end function var_list_get_ival
 
   function var_list_get_rval (vars, name, follow_link) result (rval)
     real(default) :: rval
     type(string_t), intent(in) :: name
     class(var_list_t), intent(in) :: vars
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr &
          (vars, name, V_REAL, follow_link, defined=.true.)
     if (associated (var)) then
        if (var_has_value (var)) then
           rval = var%rval
        else
           rval = 0
        end if
     else
        rval = 0
     end if
   end function var_list_get_rval
 
   function var_list_get_cval (vars, name, follow_link) result (cval)
     complex(default) :: cval
     type(string_t), intent(in) :: name
     class(var_list_t), intent(in) :: vars
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr &
          (vars, name, V_CMPLX, follow_link, defined=.true.)
     if (associated (var)) then
        if (var_has_value (var)) then
           cval = var%cval
        else
           cval = 0
        end if
     else
        cval = 0
     end if
   end function var_list_get_cval
 
   function var_list_get_aval (vars, name, follow_link) result (aval)
     type(pdg_array_t) :: aval
     type(string_t), intent(in) :: name
     class(var_list_t), intent(in) :: vars
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr &
          (vars, name, V_PDG, follow_link, defined=.true.)
     if (associated (var)) then
        if (var_has_value (var)) then
           aval = var%aval
        end if
     end if
   end function var_list_get_aval
 
   function var_list_get_pval (vars, name, follow_link) result (pval)
     type(subevt_t) :: pval
     type(string_t), intent(in) :: name
     class(var_list_t), intent(in) :: vars
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr &
          (vars, name, V_SEV, follow_link, defined=.true.)
     if (associated (var)) then
        if (var_has_value (var)) then
           pval = var%pval
        end if
     end if
   end function var_list_get_pval
 
   function var_list_get_sval (vars, name, follow_link) result (sval)
     type(string_t) :: sval
     type(string_t), intent(in) :: name
     class(var_list_t), intent(in) :: vars
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr &
          (vars, name, V_STR, follow_link, defined=.true.)
     if (associated (var)) then
        if (var_has_value (var)) then
           sval = var%sval
        else
           sval = ""
        end if
     else
        sval = ""
     end if
   end function var_list_get_sval
 
 @ %def var_list_get_lval
 @ %def var_list_get_ival
 @ %def var_list_get_rval
 @ %def var_list_get_cval
 @ %def var_list_get_pval
 @ %def var_list_get_aval
 @ %def var_list_get_sval
 @ Check for a valid value, given a pointer.  Issue error messages if invalid.
 <<Variables: procedures>>=
   function var_has_value (var) result (valid)
     logical :: valid
     type(var_entry_t), pointer :: var
     if (associated (var)) then
        if (var%is_known) then
           valid = .true.
        else
           call msg_error ("The value of variable '" // char (var%name) &
                // "' is unknown but must be known at this point.")
           valid = .false.
        end if
     else
        call msg_error ("Variable '" // char (var%name) &
             // "' is undefined but must have a known value at this point.")
        valid = .false.
     end if
   end function var_has_value
 
 @ %def var_has_value
 @ Return pointers instead of values, including a pointer to the
 [[known]] entry.
 <<Variables: var list: TBP>>=
   procedure :: get_lptr => var_list_get_lptr
   procedure :: get_iptr => var_list_get_iptr
   procedure :: get_rptr => var_list_get_rptr
   procedure :: get_cptr => var_list_get_cptr
   procedure :: get_aptr => var_list_get_aptr
   procedure :: get_pptr => var_list_get_pptr
   procedure :: get_sptr => var_list_get_sptr
 <<Variables: procedures>>=
   subroutine var_list_get_lptr (var_list, name, lptr, known)
     class(var_list_t), intent(in) :: var_list
     type(string_t), intent(in) :: name
     logical, pointer, intent(out) :: lptr
     logical, pointer, intent(out), optional :: known
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_LOG)
     if (associated (var)) then
        lptr => var_entry_get_lval_ptr (var)
        if (present (known))  known => var_entry_get_known_ptr (var)
     else
        lptr => null ()
        if (present (known))  known => null ()
     end if
   end subroutine var_list_get_lptr
 
   subroutine var_list_get_iptr (var_list, name, iptr, known)
     class(var_list_t), intent(in) :: var_list
     type(string_t), intent(in) :: name
     integer, pointer, intent(out) :: iptr
     logical, pointer, intent(out), optional :: known
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_INT)
     if (associated (var)) then
        iptr => var_entry_get_ival_ptr (var)
        if (present (known))  known => var_entry_get_known_ptr (var)
     else
        iptr => null ()
        if (present (known))  known => null ()
     end if
   end subroutine var_list_get_iptr
 
   subroutine var_list_get_rptr (var_list, name, rptr, known)
     class(var_list_t), intent(in) :: var_list
     type(string_t), intent(in) :: name
     real(default), pointer, intent(out) :: rptr
     logical, pointer, intent(out), optional :: known
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_REAL)
     if (associated (var)) then
        rptr => var_entry_get_rval_ptr (var)
        if (present (known))  known => var_entry_get_known_ptr (var)
     else
        rptr => null ()
        if (present (known))  known => null ()
     end if
   end subroutine var_list_get_rptr
 
   subroutine var_list_get_cptr (var_list, name, cptr, known)
     class(var_list_t), intent(in) :: var_list
     type(string_t), intent(in) :: name
     complex(default), pointer, intent(out) :: cptr
     logical, pointer, intent(out), optional :: known
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_CMPLX)
     if (associated (var)) then
        cptr => var_entry_get_cval_ptr (var)
        if (present (known))  known => var_entry_get_known_ptr (var)
     else
        cptr => null ()
        if (present (known))  known => null ()
     end if
   end subroutine var_list_get_cptr
 
   subroutine var_list_get_aptr (var_list, name, aptr, known)
     class(var_list_t), intent(in) :: var_list
     type(string_t), intent(in) :: name
     type(pdg_array_t), pointer, intent(out) :: aptr
     logical, pointer, intent(out), optional :: known
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_PDG)
     if (associated (var)) then
        aptr => var_entry_get_aval_ptr (var)
        if (present (known))  known => var_entry_get_known_ptr (var)
     else
        aptr => null ()
        if (present (known))  known => null ()
     end if
   end subroutine var_list_get_aptr
 
   subroutine var_list_get_pptr (var_list, name, pptr, known)
     class(var_list_t), intent(in) :: var_list
     type(string_t), intent(in) :: name
     type(subevt_t), pointer, intent(out) :: pptr
     logical, pointer, intent(out), optional :: known
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_SEV)
     if (associated (var)) then
        pptr => var_entry_get_pval_ptr (var)
        if (present (known))  known => var_entry_get_known_ptr (var)
     else
        pptr => null ()
        if (present (known))  known => null ()
     end if
   end subroutine var_list_get_pptr
 
   subroutine var_list_get_sptr (var_list, name, sptr, known)
     class(var_list_t), intent(in) :: var_list
     type(string_t), intent(in) :: name
     type(string_t), pointer, intent(out) :: sptr
     logical, pointer, intent(out), optional :: known
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_STR)
     if (associated (var)) then
        sptr => var_entry_get_sval_ptr (var)
        if (present (known))  known => var_entry_get_known_ptr (var)
     else
        sptr => null ()
        if (present (known))  known => null ()
     end if
   end subroutine var_list_get_sptr
 
 @ %def var_list_get_lptr
 @ %def var_list_get_iptr
 @ %def var_list_get_rptr
 @ %def var_list_get_cptr
 @ %def var_list_get_aptr
 @ %def var_list_get_pptr
 @ %def var_list_get_sptr
 @
 This bunch of methods handles the procedure-pointer cases.
 <<Variables: var list: TBP>>=
   procedure :: get_obs1_iptr => var_list_get_obs1_iptr
   procedure :: get_obs2_iptr => var_list_get_obs2_iptr
   procedure :: get_obs1_rptr => var_list_get_obs1_rptr
   procedure :: get_obs2_rptr => var_list_get_obs2_rptr
 <<Variables: procedures>>=
   subroutine var_list_get_obs1_iptr (var_list, name, obs1_iptr, p1)
     class(var_list_t), intent(in) :: var_list
     type(string_t), intent(in) :: name
     procedure(obs_unary_int), pointer, intent(out) :: obs1_iptr
     type(prt_t), pointer, intent(out) :: p1
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_OBS1_INT)
     if (associated (var)) then
        call var_entry_assign_obs1_int_ptr (obs1_iptr, var)
        p1 => var_entry_get_prt1_ptr (var)
     else
        obs1_iptr => null ()
        p1 => null ()
     end if
   end subroutine var_list_get_obs1_iptr
 
   subroutine var_list_get_obs2_iptr (var_list, name, obs2_iptr, p1, p2)
     class(var_list_t), intent(in) :: var_list
     type(string_t), intent(in) :: name
     procedure(obs_binary_int), pointer, intent(out) :: obs2_iptr
     type(prt_t), pointer, intent(out) :: p1, p2
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_OBS2_INT)
     if (associated (var)) then
        call var_entry_assign_obs2_int_ptr (obs2_iptr, var)
        p1 => var_entry_get_prt1_ptr (var)
        p2 => var_entry_get_prt2_ptr (var)
     else
        obs2_iptr => null ()
        p1 => null ()
        p2 => null ()
     end if
   end subroutine var_list_get_obs2_iptr
 
   subroutine var_list_get_obs1_rptr (var_list, name, obs1_rptr, p1)
     class(var_list_t), intent(in) :: var_list
     type(string_t), intent(in) :: name
     procedure(obs_unary_real), pointer, intent(out) :: obs1_rptr
     type(prt_t), pointer, intent(out) :: p1
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_OBS1_REAL)
     if (associated (var)) then
        call var_entry_assign_obs1_real_ptr (obs1_rptr, var)
        p1 => var_entry_get_prt1_ptr (var)
     else
        obs1_rptr => null ()
        p1 => null ()
     end if
   end subroutine var_list_get_obs1_rptr
 
   subroutine var_list_get_obs2_rptr (var_list, name, obs2_rptr, p1, p2)
     class(var_list_t), intent(in) :: var_list
     type(string_t), intent(in) :: name
     procedure(obs_binary_real), pointer, intent(out) :: obs2_rptr
     type(prt_t), pointer, intent(out) :: p1, p2
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_OBS2_REAL)
     if (associated (var)) then
        call var_entry_assign_obs2_real_ptr (obs2_rptr, var)
        p1 => var_entry_get_prt1_ptr (var)
        p2 => var_entry_get_prt2_ptr (var)
     else
        obs2_rptr => null ()
        p1 => null ()
        p2 => null ()
     end if
   end subroutine var_list_get_obs2_rptr
 
 @ %def var_list_get_obs1_iptr
 @ %def var_list_get_obs2_iptr
 @ %def var_list_get_obs1_rptr
 @ %def var_list_get_obs2_rptr
 @
 \subsection{Process Result Variables}
 These variables are associated to process (integration) runs and their
 results.  Their names contain brackets (so they look like function
 evaluations), therefore we need to special-case them.
 <<Variables: public>>=
   public :: var_list_set_procvar_int
   public :: var_list_set_procvar_real
 <<Variables: procedures>>=
   subroutine var_list_set_procvar_int (var_list, proc_id, name, ival)
     type(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: proc_id
     type(string_t), intent(in) :: name
     integer, intent(in), optional :: ival
     type(string_t) :: var_name
     type(var_entry_t), pointer :: var
     var_name = name // "(" // proc_id // ")"
     var => var_list_get_var_ptr (var_list, var_name)
     if (.not. associated (var)) then
        call var_list%append_int (var_name, ival, intrinsic=.true.)
     else if (present (ival)) then
        call var_list%set_int (var_name, ival, is_known=.true.)
     end if
   end subroutine var_list_set_procvar_int
 
   subroutine var_list_set_procvar_real (var_list, proc_id, name, rval)
     type(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: proc_id
     type(string_t), intent(in) :: name
     real(default), intent(in), optional :: rval
     type(string_t) :: var_name
     type(var_entry_t), pointer :: var
     var_name = name // "(" // proc_id // ")"
     var => var_list_get_var_ptr (var_list, var_name)
     if (.not. associated (var)) then
        call var_list%append_real (var_name, rval, intrinsic=.true.)
     else if (present (rval)) then
        call var_list%set_real (var_name, rval, is_known=.true.)
     end if
   end subroutine var_list_set_procvar_real
 
 @ %def var_list_set_procvar_int
 @ %def var_list_set_procvar_real
 @
 \subsection{Observable initialization}
 Observables are formally treated as variables, which however are
 evaluated each time the observable is used.  The arguments (pointers)
 to evaluate and the function are part of the variable-list entry.
 <<Variables: public>>=
   public :: var_list_append_obs1_iptr
   public :: var_list_append_obs2_iptr
   public :: var_list_append_obs1_rptr
   public :: var_list_append_obs2_rptr
 <<Variables: procedures>>=
   subroutine var_list_append_obs1_iptr (var_list, name, obs1_iptr, p1)
     type(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     procedure(obs_unary_int) :: obs1_iptr
     type(prt_t), intent(in), target :: p1
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_obs (var, name, V_OBS1_INT, p1)
     var%obs1_int => obs1_iptr
     call var_list_append (var_list, var)
   end subroutine var_list_append_obs1_iptr
 
   subroutine var_list_append_obs2_iptr (var_list, name, obs2_iptr, p1, p2)
     type(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     procedure(obs_binary_int) :: obs2_iptr
     type(prt_t), intent(in), target :: p1, p2
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_obs (var, name, V_OBS2_INT, p1, p2)
     var%obs2_int => obs2_iptr
     call var_list_append (var_list, var)
   end subroutine var_list_append_obs2_iptr
 
   subroutine var_list_append_obs1_rptr (var_list, name, obs1_rptr, p1)
     type(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     procedure(obs_unary_real) :: obs1_rptr
     type(prt_t), intent(in), target :: p1
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_obs (var, name, V_OBS1_REAL, p1)
     var%obs1_real => obs1_rptr
     call var_list_append (var_list, var)
   end subroutine var_list_append_obs1_rptr
 
   subroutine var_list_append_obs2_rptr (var_list, name, obs2_rptr, p1, p2)
     type(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     procedure(obs_binary_real) :: obs2_rptr
     type(prt_t), intent(in), target :: p1, p2
     type(var_entry_t), pointer :: var
     allocate (var)
     call var_entry_init_obs (var, name, V_OBS2_REAL, p1, p2)
     var%obs2_real => obs2_rptr
     call var_list_append (var_list, var)
   end subroutine var_list_append_obs2_rptr
 
 @ %def var_list_append_obs1_iptr
 @ %def var_list_append_obs2_iptr
 @ %def var_list_append_obs1_rptr
 @ %def var_list_append_obs2_rptr
 @ User observables: no pointer needs to be stored.
 <<Variables: public>>=
   public :: var_list_append_uobs_int
   public :: var_list_append_uobs_real
 <<Variables: procedures>>=
   subroutine var_list_append_uobs_int (var_list, name, p1, p2)
     type(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     type(prt_t), intent(in), target :: p1
     type(prt_t), intent(in), target, optional :: p2
     type(var_entry_t), pointer :: var
     allocate (var)
     if (present (p2)) then
        call var_entry_init_obs (var, name, V_UOBS2_INT, p1, p2)
     else
        call var_entry_init_obs (var, name, V_UOBS1_INT, p1)
     end if
     call var_list_append (var_list, var)
   end subroutine var_list_append_uobs_int
 
   subroutine var_list_append_uobs_real (var_list, name, p1, p2)
     type(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: name
     type(prt_t), intent(in), target :: p1
     type(prt_t), intent(in), target, optional :: p2
     type(var_entry_t), pointer :: var
     allocate (var)
     if (present (p2)) then
        call var_entry_init_obs (var, name, V_UOBS2_REAL, p1, p2)
     else
        call var_entry_init_obs (var, name, V_UOBS1_REAL, p1)
     end if
     call var_list_append (var_list, var)
   end subroutine var_list_append_uobs_real
 
 @ %def var_list_append_uobs_int
 @ %def var_list_append_uobs_real
 @
 \subsection{API for variable lists}
 Set a new value.  If the variable holds a pointer, this pointer is
 followed, e.g., a model parameter is actually set.  If [[ignore]] is
 set, do nothing if the variable does not exist.  If [[verbose]] is
 set, echo the new value.
 
 Clear a variable (all variables), i.e., undefine the value.
 <<Variables: var list: TBP>>=
   procedure :: unset => var_list_clear
 <<Variables: procedures>>=
   subroutine var_list_clear (vars, name, follow_link)
     class(var_list_t), intent(inout) :: vars
     type(string_t), intent(in) :: name
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (vars, name, follow_link=follow_link)
     if (associated (var)) then
        call var_entry_clear (var)
     end if
   end subroutine var_list_clear
 
 @ %def var_list_clear
 @
 Setting the value, concise specific versions (implementing deferred TBP):
 <<Variables: var list: TBP>>=
   procedure :: set_ival => var_list_set_ival
   procedure :: set_rval => var_list_set_rval
   procedure :: set_cval => var_list_set_cval
   procedure :: set_lval => var_list_set_lval
   procedure :: set_sval => var_list_set_sval
 <<Variables: procedures>>=
   subroutine var_list_set_ival (vars, name, ival, follow_link)
     class(var_list_t), intent(inout) :: vars
     type(string_t), intent(in) :: name
     integer, intent(in) :: ival
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (vars, name, follow_link=follow_link)
     if (associated (var)) then
        call var_entry_set_int (var, ival, is_known=.true.)
     end if
   end subroutine var_list_set_ival
 
   subroutine var_list_set_rval (vars, name, rval, follow_link)
     class(var_list_t), intent(inout) :: vars
     type(string_t), intent(in) :: name
     real(default), intent(in) :: rval
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (vars, name, follow_link=follow_link)
     if (associated (var)) then
        call var_entry_set_real (var, rval, is_known=.true.)
     end if
   end subroutine var_list_set_rval
 
   subroutine var_list_set_cval (vars, name, cval, follow_link)
     class(var_list_t), intent(inout) :: vars
     type(string_t), intent(in) :: name
     complex(default), intent(in) :: cval
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (vars, name, follow_link=follow_link)
     if (associated (var)) then
        call var_entry_set_cmplx (var, cval, is_known=.true.)
     end if
   end subroutine var_list_set_cval
 
   subroutine var_list_set_lval (vars, name, lval, follow_link)
     class(var_list_t), intent(inout) :: vars
     type(string_t), intent(in) :: name
     logical, intent(in) :: lval
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (vars, name, follow_link=follow_link)
     if (associated (var)) then
        call var_entry_set_log (var, lval, is_known=.true.)
     end if
   end subroutine var_list_set_lval
 
   subroutine var_list_set_sval (vars, name, sval, follow_link)
     class(var_list_t), intent(inout) :: vars
     type(string_t), intent(in) :: name
     type(string_t), intent(in) :: sval
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (vars, name, follow_link=follow_link)
     if (associated (var)) then
        call var_entry_set_string (var, sval, is_known=.true.)
     end if
   end subroutine var_list_set_sval
 
 @ %def var_list_set_ival
 @ %def var_list_set_rval
 @ %def var_list_set_cval
 @ %def var_list_set_lval
 @ %def var_list_set_sval
 @
 Setting the value, verbose specific versions (as subroutines):
 <<Variables: var list: TBP>>=
   procedure :: set_log => var_list_set_log
   procedure :: set_int => var_list_set_int
   procedure :: set_real => var_list_set_real
   procedure :: set_cmplx => var_list_set_cmplx
   procedure :: set_subevt => var_list_set_subevt
   procedure :: set_pdg_array => var_list_set_pdg_array
   procedure :: set_string => var_list_set_string
 <<Variables: procedures>>=
   subroutine var_list_set_log &
        (var_list, name, lval, is_known, ignore, force, verbose, model_name)
     class(var_list_t), intent(inout), target :: var_list
     type(string_t), intent(in) :: name
     logical, intent(in) :: lval
     logical, intent(in) :: is_known
     logical, intent(in), optional :: ignore, force, verbose
     type(string_t), intent(in), optional :: model_name
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_LOG)
     if (associated (var)) then
        if (.not. var_entry_is_locked (var, force)) then
           select case (var%type)
           case (V_LOG)
              call var_entry_set_log (var, lval, is_known, verbose, model_name)
           case default
              call var_mismatch_error (name)
           end select
        else
           call var_locked_error (name)
        end if
     else
        call var_missing_error (name, ignore)
     end if
   end subroutine var_list_set_log
 
   subroutine var_list_set_int &
        (var_list, name, ival, is_known, ignore, force, verbose, model_name)
     class(var_list_t), intent(inout), target :: var_list
     type(string_t), intent(in) :: name
     integer, intent(in) :: ival
     logical, intent(in) :: is_known
     logical, intent(in), optional :: ignore, force, verbose
     type(string_t), intent(in), optional :: model_name
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_INT)
     if (associated (var)) then
        if (.not. var_entry_is_locked (var, force)) then
           select case (var%type)
           case (V_INT)
              call var_entry_set_int (var, ival, is_known, verbose, model_name)
           case default
              call var_mismatch_error (name)
           end select
        else
           call var_locked_error (name)
        end if
     else
        call var_missing_error (name, ignore)
     end if
   end subroutine var_list_set_int
 
   subroutine var_list_set_real &
        (var_list, name, rval, is_known, ignore, force, &
         verbose, model_name, pacified)
     class(var_list_t), intent(inout), target :: var_list
     type(string_t), intent(in) :: name
     real(default), intent(in) :: rval
     logical, intent(in) :: is_known
     logical, intent(in), optional :: ignore, force, verbose, pacified
     type(string_t), intent(in), optional :: model_name
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_REAL)
     if (associated (var)) then
        if (.not. var_entry_is_locked (var, force)) then
           select case (var%type)
           case (V_REAL)
              call var_entry_set_real &
                   (var, rval, is_known, verbose, model_name, pacified)
           case default
              call var_mismatch_error (name)
           end select
        else
           call var_locked_error (name)
        end if
     else
        call var_missing_error (name, ignore)
     end if
   end subroutine var_list_set_real
 
   subroutine var_list_set_cmplx &
        (var_list, name, cval, is_known, ignore, force, &
         verbose, model_name, pacified)
     class(var_list_t), intent(inout), target :: var_list
     type(string_t), intent(in) :: name
     complex(default), intent(in) :: cval
     logical, intent(in) :: is_known
     logical, intent(in), optional :: ignore, force, verbose, pacified
     type(string_t), intent(in), optional :: model_name
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_CMPLX)
     if (associated (var)) then
        if (.not. var_entry_is_locked (var, force)) then
           select case (var%type)
           case (V_CMPLX)
              call var_entry_set_cmplx &
                   (var, cval, is_known, verbose, model_name, pacified)
           case default
              call var_mismatch_error (name)
           end select
        else
           call var_locked_error (name)
        end if
     else
        call var_missing_error (name, ignore)
     end if
   end subroutine var_list_set_cmplx
 
   subroutine var_list_set_pdg_array &
        (var_list, name, aval, is_known, ignore, force, verbose, model_name)
     class(var_list_t), intent(inout), target :: var_list
     type(string_t), intent(in) :: name
     type(pdg_array_t), intent(in) :: aval
     logical, intent(in) :: is_known
     logical, intent(in), optional :: ignore, force, verbose
     type(string_t), intent(in), optional :: model_name
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_PDG)
     if (associated (var)) then
        if (.not. var_entry_is_locked (var, force)) then
           select case (var%type)
           case (V_PDG)
              call var_entry_set_pdg_array &
                   (var, aval, is_known, verbose, model_name)
           case default
              call var_mismatch_error (name)
           end select
        else
           call var_locked_error (name)
        end if
     else
        call var_missing_error (name, ignore)
     end if
   end subroutine var_list_set_pdg_array
 
   subroutine var_list_set_subevt &
        (var_list, name, pval, is_known, ignore, force, verbose, model_name)
     class(var_list_t), intent(inout), target :: var_list
     type(string_t), intent(in) :: name
     type(subevt_t), intent(in) :: pval
     logical, intent(in) :: is_known
     logical, intent(in), optional :: ignore, force, verbose
     type(string_t), intent(in), optional :: model_name
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_SEV)
     if (associated (var)) then
        if (.not. var_entry_is_locked (var, force)) then
           select case (var%type)
           case (V_SEV)
              call var_entry_set_subevt &
                   (var, pval, is_known, verbose, model_name)
           case default
              call var_mismatch_error (name)
           end select
        else
           call var_locked_error (name)
        end if
     else
        call var_missing_error (name, ignore)
     end if
   end subroutine var_list_set_subevt
 
   subroutine var_list_set_string &
        (var_list, name, sval, is_known, ignore, force, verbose, model_name)
     class(var_list_t), intent(inout), target :: var_list
     type(string_t), intent(in) :: name
     type(string_t), intent(in) :: sval
     logical, intent(in) :: is_known
     logical, intent(in), optional :: ignore, force, verbose
     type(string_t), intent(in), optional :: model_name
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name, V_STR)
     if (associated (var)) then
        if (.not. var_entry_is_locked (var, force)) then
           select case (var%type)
           case (V_STR)
              call var_entry_set_string &
                   (var, sval, is_known, verbose, model_name)
           case default
              call var_mismatch_error (name)
           end select
        else
           call var_locked_error (name)
        end if
     else
        call var_missing_error (name, ignore)
     end if
   end subroutine var_list_set_string
 
   subroutine var_mismatch_error (name)
     type(string_t), intent(in) :: name
     call msg_fatal ("Type mismatch for variable '" // char (name) // "'")
   end subroutine var_mismatch_error
 
   subroutine var_locked_error (name)
     type(string_t), intent(in) :: name
     call msg_error ("Variable '" // char (name) // "' is not user-definable")
   end subroutine var_locked_error
 
   subroutine var_missing_error (name, ignore)
     type(string_t), intent(in) :: name
     logical, intent(in), optional :: ignore
     logical :: error
     if (present (ignore)) then
        error = .not. ignore
     else
        error = .true.
     end if
     if (error) then
        call msg_fatal ("Variable '" // char (name) // "' has not been declared")
     end if
   end subroutine var_missing_error
 
 @ %def var_list_set_log
 @ %def var_list_set_int
 @ %def var_list_set_real
 @ %def var_list_set_cmplx
 @ %def var_list_set_subevt
 @ %def var_list_set_pdg_array
 @ %def var_list_set_string
 @ %def var_mismatch_error
 @ %def var_missing_error
 @
 Import values for the current variable list from another list.
 <<Variables: public>>=
   public :: var_list_import
 <<Variables: var list: TBP>>=
   procedure :: import => var_list_import
 <<Variables: procedures>>=
   subroutine var_list_import (var_list, src_list)
     class(var_list_t), intent(inout) :: var_list
     type(var_list_t), intent(in) :: src_list
     type(var_entry_t), pointer :: var, src
     var => var_list%first
     do while (associated (var))
        src => var_list_get_var_ptr (src_list, var%name)
        if (associated (src)) then
           call var_entry_copy_value (var, src)
        end if
        var => var%next
     end do
   end subroutine var_list_import
 
 @ %def var_list_import
 @ Mark all entries in the current variable list as undefined.  This is done
 when a local variable list is discarded.  If the local list is used again (by
 a loop), the entries will be re-initialized.
 <<Variables: public>>=
   public :: var_list_undefine
 <<Variables: var list: TBP>>=
   procedure :: undefine => var_list_undefine
 <<Variables: procedures>>=
   recursive subroutine var_list_undefine (var_list, follow_link)
     class(var_list_t), intent(inout) :: var_list
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var
     logical :: rec
     rec = .true.;  if (present (follow_link))  rec = follow_link
     var => var_list%first
     do while (associated (var))
        call var_entry_undefine (var)
        var => var%next
     end do
     if (rec .and. associated (var_list%next)) then
        call var_list_undefine (var_list%next, follow_link=follow_link)
     end if
   end subroutine var_list_undefine
 
 @ %def var_list_undefine
 @ Make a deep copy of a variable list.
 <<Variables: public>>=
   public :: var_list_init_snapshot
 <<Variables: var list: TBP>>=
   procedure :: init_snapshot => var_list_init_snapshot
 <<Variables: procedures>>=
   recursive subroutine var_list_init_snapshot (var_list, vars_in, follow_link)
     class(var_list_t), intent(out) :: var_list
     type(var_list_t), intent(in) :: vars_in
     logical, intent(in), optional :: follow_link
     type(var_entry_t), pointer :: var, var_in
     type(var_list_t), pointer :: var_list_next
     logical :: rec
     rec = .true.;  if (present (follow_link))  rec = follow_link
     var_in => vars_in%first
     do while (associated (var_in))
        allocate (var)
        call var_entry_init_copy (var, var_in)
        call var_entry_copy_value (var, var_in)
        call var_list_append (var_list, var)
        var_in => var_in%next
     end do
     if (rec .and. associated (vars_in%next)) then
        allocate (var_list_next)
        call var_list_init_snapshot (var_list_next, vars_in%next)
        call var_list%link (var_list_next)
     end if
   end subroutine var_list_init_snapshot
 
 @ %def var_list_init_snapshot
 @ Check if a user variable can be set.  The [[new]] flag is set if the user
 variable has an explicit declaration.  If an error occurs, return [[V_NONE]]
 as variable type.
 
 Also determine the actual type of generic numerical variables, which enter the
 procedure with type [[V_NONE]].
 <<Variables: public>>=
   public :: var_list_check_user_var
 <<Variables: var list: TBP>>=
   procedure :: check_user_var => var_list_check_user_var
 <<Variables: procedures>>=
   subroutine var_list_check_user_var (var_list, name, type, new)
     class(var_list_t), intent(in), target :: var_list
     type(string_t), intent(in) :: name
     integer, intent(inout) :: type
     logical, intent(in) :: new
     type(var_entry_t), pointer :: var
     var => var_list_get_var_ptr (var_list, name)
     if (associated (var)) then
        if (type == V_NONE) then
           type = var_entry_get_type (var)
        end if
        if (var_entry_is_locked (var)) then
           call msg_fatal ("Variable '" // char (name) &
                // "' is not user-definable")
           type = V_NONE
           return
        else if (new) then
           if (var_entry_is_intrinsic (var)) then
              call msg_fatal ("Intrinsic variable '" &
                   // char (name) // "' redeclared")
              type = V_NONE
              return
           end if
           if (var_entry_get_type (var) /= type) then
              call msg_fatal ("Variable '" // char (name) // "' " &
                   // "redeclared with different type")
              type = V_NONE
              return
           end if
        end if
     end if
   end subroutine var_list_check_user_var
 
 @ %def var_list_check_user_var
 @
 \subsection{Default values for global var list}
 
 <<Variables: var list: TBP>>=
   procedure :: init_defaults => var_list_init_defaults
 <<Variables: procedures>>=
   subroutine var_list_init_defaults (var_list, seed, paths)
     class(var_list_t), intent(out) :: var_list
     integer, intent(in) :: seed
     type(paths_t), intent(in), optional :: paths
     call var_list%set_beams_defaults (paths)
     call var_list%set_core_defaults (seed)
     call var_list%set_integration_defaults ()
     call var_list%set_phase_space_defaults ()
     call var_list%set_gamelan_defaults ()
     call var_list%set_clustering_defaults ()
     call var_list%set_eio_defaults ()
     call var_list%set_shower_defaults ()
     call var_list%set_hadronization_defaults ()
     call var_list%set_tauola_defaults  ()
     call var_list%set_mlm_matching_defaults ()
     call var_list%set_powheg_matching_defaults ()
     call var_list%append_log (var_str ("?ckkw_matching"), .false., &
             intrinsic=.true., description=var_str ('Master flag that switches ' // &
             'on the CKKW(-L) (LO) matching between hard scattering matrix ' // &
             'elements and QCD parton showers. Note that this is not yet ' // &
             '(completely) implemented in \whizard. (cf. also \ttt{?allow\_shower}, ' // &
             '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...})'))
     call var_list%set_openmp_defaults ()
     call var_list%set_mpi_defaults ()
     call var_list%set_nlo_defaults ()
   end subroutine var_list_init_defaults
 
 @ %def var_list_init_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_beams_defaults => var_list_set_beams_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_beams_defaults (var_list, paths)
     type(paths_t), intent(in), optional :: paths
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_real (var_str ("sqrts"), &
           intrinsic=.true., &
           description=var_str ('Real variable in order to set the center-of-mass ' // &
           'energy for the collisions (collider energy $\sqrt{s}$, not ' // &
           'hard interaction energy $\sqrt{\hat{s}}$): \ttt{sqrts = {\em ' // &
           '<num>} [ {\em <phys\_unit>} ]}. The physical unit can be one ' // &
           'of the following \ttt{eV}, \ttt{keV}, \ttt{MeV}, \ttt{GeV}, ' // &
           'and \ttt{TeV}. If absent, \whizard\ takes \ttt{GeV} as its ' // &
           'standard unit. Note that this variable is absolutely mandatory ' // &
           'for integration and simulation of scattering processes.'))
     call var_list%append_real (var_str ("luminosity"), 0._default, &
           intrinsic=.true., &
           description=var_str ('This specifier \ttt{luminosity = {\em ' // &
           '<num>}} sets the integrated luminosity (in inverse femtobarns, ' // &
           'fb${}^{-1}$) for the event generation of the processes in the ' // &
           '\sindarin\ input files. Note that WHIZARD itself chooses the ' // &
           'number from the \ttt{luminosity} or from the \ttt{n\_events} ' // &
           'specifier, whichever would give the larger number of events. ' // &
           'As this depends on the cross section under consideration, it ' // &
           'might be different for different processes in the process list.  ' // &
           '(cf. \ttt{n\_events}, \ttt{\$sample}, \ttt{sample\_format}, \ttt{?unweighted})'))
     call var_list%append_log (var_str ("?sf_trace"), .false., &
           intrinsic=.true., &
           description=var_str ('Debug flag that writes out detailed information ' // &
           'about the structure function setup into the file \ttt{{\em ' // &
           '<proc\_name>}\_sftrace.dat}. This file name can be changed ' // &
           'with ($\to$) \ttt{\$sf\_trace\_file}.'))
     call var_list%append_string (var_str ("$sf_trace_file"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('\ttt{\$sf\_trace\_file = "{\em <file\_name>}"} ' // &
           'allows to change the detailed structure function information ' // &
           'switched on by the debug flag ($\to$) \ttt{?sf\_trace} into ' // &
           'a different file \ttt{{\em <file\_name>}} than the default ' // &
           '\ttt{{\em <proc\_name>}\_sftrace.dat}.'))
     call var_list%append_log (var_str ("?sf_allow_s_mapping"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that determines whether special mappings ' // &
           'for processes with structure functions and $s$-channel resonances ' // &
           'are applied, e.g. Drell-Yan at hadron colliders, or $Z$ production ' // &
           'at linear colliders with beamstrahlung and ISR.'))
     if (present (paths)) then
        call var_list%append_string (var_str ("$lhapdf_dir"), paths%lhapdfdir, &
              intrinsic=.true., &
              description=var_str ('String variable that tells the path ' // &
              'where the \lhapdf\ library and PDF sets can be found. When ' // &
              'the library has been correctly recognized during configuration, ' // &
              'this is automatically set by \whizard. (cf. also \ttt{lhapdf}, ' // &
              '\ttt{\$lhapdf\_file}, \ttt{lhapdf\_photon}, \ttt{\$lhapdf\_photon\_file}, ' // &
              '\ttt{lhapdf\_member}, \ttt{lhapdf\_photon\_scheme})'))
     else
        call var_list%append_string (var_str ("$lhapdf_dir"), var_str(""), &
              intrinsic=.true., &
              description=var_str ('String variable that tells the path ' // &
              'where the \lhapdf\ library and PDF sets can be found. When ' // &
              'the library has been correctly recognized during configuration, ' // &
              'this is automatically set by \whizard. (cf. also \ttt{lhapdf}, ' // &
              '\ttt{\$lhapdf\_file}, \ttt{lhapdf\_photon}, \ttt{\$lhapdf\_photon\_file}, ' // &
              '\ttt{lhapdf\_member}, \ttt{lhapdf\_photon\_scheme})'))
     end if
     call var_list%append_string (var_str ("$lhapdf_file"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('This string variable \ttt{\$lhapdf\_file ' // &
           '= "{\em <pdf\_set>}"} allows to specify the PDF set \ttt{{\em ' // &
           '<pdf\_set>}} from the external \lhapdf\ library. It must match ' // &
           'the exact name of the PDF set from the \lhapdf\ library. The ' // &
           'default is empty, and the default set from \lhapdf\ is taken. ' // &
           'Only one argument is possible, the PDF set must be identical ' // &
           'for both beams, unless there are fundamentally different beam ' // &
           'particles like proton and photon. (cf. also \ttt{lhapdf}, \ttt{\$lhapdf\_dir}, ' // &
           '\ttt{lhapdf\_photon}, \ttt{\$lhapdf\_photon\_file}, \ttt{lhapdf\_photon\_scheme}, ' // &
           '\ttt{lhapdf\_member})'))
     call var_list%append_string (var_str ("$lhapdf_photon_file"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('String variable \ttt{\$lhapdf\_photon\_file ' // &
           '= "{\em <pdf\_set>}"} analagous to ($\to$) \ttt{\$lhapdf\_file} ' // &
           'for photon PDF structure functions from the external \lhapdf\ ' // &
           'library. The name must exactly match the one of the set from ' // &
           '\lhapdf.  (cf. \ttt{beams}, \ttt{lhapdf}, \ttt{\$lhapdf\_dir}, ' // &
           '\ttt{\$lhapdf\_file}, \ttt{\$lhapdf\_photon\_file}, \ttt{lhapdf\_member}, ' // &
           '\ttt{lhapdf\_photon\_scheme})'))
     call var_list%append_int (var_str ("lhapdf_member"), 0, &
           intrinsic=.true., &
           description=var_str ('Integer variable that specifies the number ' // &
           'of the corresponding PDF set chosen via the command ($\to$) ' // &
           '\ttt{\$lhapdf\_file} or ($\to$) \ttt{\$lhapdf\_photon\_file} ' // &
           'from the external \lhapdf\ library. E.g. error PDF sets can ' // &
           'be chosen by this. (cf. also \ttt{lhapdf}, \ttt{\$lhapdf\_dir}, ' // &
           '\ttt{\$lhapdf\_file}, \ttt{lhapdf\_photon}, \ttt{\$lhapdf\_photon\_file}, ' // &
           '\ttt{lhapdf\_photon\_scheme})'))
     call var_list%append_int (var_str ("lhapdf_photon_scheme"), 0, &
           intrinsic=.true., &
           description=var_str ('Integer parameter that controls the different ' // &
           'available schemes for photon PDFs inside the external \lhapdf\ ' // &
           'library. For more details see the \lhapdf\ manual.  (cf. also ' // &
           '\ttt{lhapdf}, \ttt{\$lhapdf\_dir}, \ttt{\$lhapdf\_file}, \ttt{lhapdf\_photon}, ' // &
           '\ttt{\$lhapdf\_photon\_file}, \ttt{lhapdf\_member})'))
     call var_list%append_string (var_str ("$pdf_builtin_set"), var_str ("CTEQ6L"), &
          intrinsic=.true., &
          description=var_str ("For \whizard's internal PDF structure functions " // &
          'for hadron colliders, this string variable allows to set the ' // &
          'particular PDF set. (cf. also \ttt{pdf\_builtin}, \ttt{pdf\_builtin\_photon})'))
     call var_list%append_log (var_str ("?hoppet_b_matching"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that switches on the matching between ' // &
           '4- and 5-flavor schemes for hadron collider $b$-parton initiated ' // &
           'processes. Works either with builtin PDFs or with the external ' // &
           '\lhapdf\ interface. Needs the external \ttt{HOPPET} library ' // &
           'to be linked. (cf. \ttt{beams}, \ttt{pdf\_builtin}, \ttt{lhapdf})'))
     call var_list%append_real (var_str ("isr_alpha"), 0._default, &
           intrinsic=.true., &
           description=var_str ('For lepton collider initial-state QED ' // &
           'radiation (ISR), this real parameter sets the value of $\alpha_{em}$ ' // &
           'used in the structure function. If not set, it is taken from ' // &
           'the parameter set of the physics model in use (cf. also \ttt{isr}, ' // &
           '\ttt{isr\_q\_max}, \ttt{isr\_mass}, \ttt{isr\_order}, \ttt{?isr\_recoil}, ' // &
           '\ttt{?isr\_keep\_energy})'))
     call var_list%append_real (var_str ("isr_q_max"), 0._default, &
           intrinsic=.true., &
           description=var_str ('This real parameter allows to set the ' // &
           'scale of the initial-state QED radiation (ISR) structure function. ' // &
           'If not set, it is taken internally to be $\sqrt{s}$.  (cf. ' // &
           'also \ttt{isr}, \ttt{isr\_alpha}, \ttt{isr\_mass}, \ttt{isr\_order}, ' // &
           '\ttt{?isr\_recoil}, \ttt{?isr\_keep\_energy})'))
     call var_list%append_real (var_str ("isr_mass"), 0._default, &
           intrinsic=.true., &
           description=var_str ('This real parameter allows to set by hand ' // &
           'the mass of the incoming particle for lepton collider initial-state ' // &
           'QED radiation (ISR). If not set, the mass for the initial beam ' // &
           'particle is taken from the model in use. (cf. also \ttt{isr}, ' // &
           '\ttt{isr\_q\_max}, \ttt{isr\_alpha}, \ttt{isr\_order}, \ttt{?isr\_recoil}, ' // &
           '\ttt{?isr\_keep\_energy})'))
     call var_list%append_int (var_str ("isr_order"), 3, &
           intrinsic=.true., &
           description=var_str ('For lepton collider initial-state QED ' // &
           'radiation (ISR), this integer parameter allows to set the order ' // &
           'up to which hard-collinear radiation is taken into account. ' // &
           'Default is the highest available, namely third order. (cf. ' // &
           'also \ttt{isr}, \ttt{isr\_q\_max}, \ttt{isr\_mass}, \ttt{isr\_alpha}, ' // &
           '\ttt{?isr\_recoil}, \ttt{?isr\_keep\_energy})'))
     call var_list%append_log (var_str ("?isr_recoil"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag to switch on recoil, i.e. a non-vanishing ' // &
           '$p_T$-kick for the lepton collider initial-state QED radiation ' // &
           '(ISR).  (cf. also \ttt{isr}, \ttt{isr}, \ttt{isr\_alpha}, \ttt{isr\_mass}, ' // &
           '\ttt{isr\_order}, \ttt{isr\_q\_max})'))
     call var_list%append_log (var_str ("?isr_keep_energy"), .false., &
           intrinsic=.true., &
           description=var_str ('As the splitting kinematics for the ISR ' // &
           'structure function violates Lorentz invariance when the recoil ' // &
           'is switched on, this flag forces energy conservation when set ' // &
           'to true, otherwise violating energy conservation.  (cf. also ' // &
           '\ttt{isr}, \ttt{isr\_q\_max}, \ttt{isr\_mass}, \ttt{isr\_order}, ' // &
           '\ttt{?isr\_recoil}, \ttt{?isr\_alpha})'))
     call var_list%append_log (var_str ("?isr_handler"), .false., &
           intrinsic=.true., &
           description=var_str ('Activate ISR ' // &
           'handler for event generation (no effect on integration). ' // &
           'Requires \ttt{isr\_recoil = false}'))
     call var_list%append_string (var_str ("$isr_handler_mode"), &
           var_str ("trivial"), &
           intrinsic=.true., &
           description=var_str ('Operation mode for the ISR ' // &
           'event handler.  Allowed values: \ttt{trivial} (no effect), ' // &
           '\ttt{recoil} (recoil kinematics with two photons)'))
     call var_list%append_real (var_str ("epa_alpha"), 0._default, &
           intrinsic=.true., &
           description=var_str ('For the equivalent photon approximation ' // &
           '(EPA), this real parameter sets the value of $\alpha_{em}$ ' // &
           'used in the structure function. If not set, it is taken from ' // &
           'the parameter set of the physics model in use (cf. also \ttt{epa}, ' // &
           '\ttt{epa\_x\_min}, \ttt{epa\_mass}, \ttt{epa\_e\_max}, \ttt{epa\_q\_min}, ' // &
           '\ttt{?epa\_recoil}, \ttt{?epa\_keep\_energy})'))
     call var_list%append_real (var_str ("epa_x_min"), 0._default, &
           intrinsic=.true., &
           description=var_str ('Real parameter that sets the lower cutoff ' // &
           'for the energy fraction in the splitting for the equivalent-photon ' // &
           'approximation (EPA). This parameter has to be set by the user ' // &
           'to a non-zero value smaller than one. (cf. also \ttt{epa}, ' // &
           '\ttt{epa\_e\_max}, \ttt{epa\_mass}, \ttt{epa\_alpha}, \ttt{epa\_q\_min}, ' // &
           '\ttt{?epa\_recoil}, \ttt{?epa\_keep\_energy})'))
     call var_list%append_real (var_str ("epa_q_min"), 0._default, &
           intrinsic=.true., &
           description=var_str ('In the equivalent-photon approximation ' // &
           '(EPA), this real parameters sets the minimal value for the ' // &
           'transferred momentum. Either this parameter or the mass of ' // &
           'the beam particle has to be non-zero.  (cf. also \ttt{epa}, ' // &
           '\ttt{epa\_x\_min}, \ttt{epa\_mass}, \ttt{epa\_alpha}, \ttt{epa\_q\_max}, ' // &
           '\ttt{?epa\_recoil}, \ttt{?epa\_keep\_energy})'))
     call var_list%append_real (var_str ("epa_q_max"), 0._default, &
           intrinsic=.true., &
           description=var_str ('This real parameter allows to set the ' // &
           'upper energy cutoff for the equivalent-photon approximation ' // &
           '(EPA). If not set, \whizard\ simply takes the collider energy, ' // &
           '$\sqrt{s}$. (cf. also \ttt{epa}, \ttt{epa\_x\_min}, \ttt{epa\_mass}, ' // &
           '\ttt{epa\_alpha}, \ttt{epa\_q\_min}, \ttt{?epa\_recoil}, \ttt{?epa\_keep\_energy})'))
     call var_list%append_real (var_str ("epa_mass"), 0._default, &
           intrinsic=.true., &
           description=var_str ('This real parameter allows to set by hand ' // &
           'the mass of the incoming particle for the equivalent-photon ' // &
           'approximation (EPA). If not set, the mass for the initial beam ' // &
           'particle is taken from the model in use. (cf. also \ttt{epa}, ' // &
           '\ttt{epa\_x\_min}, \ttt{epa\_e\_max}, \ttt{epa\_alpha}, \ttt{epa\_q\_min}, ' // &
           '\ttt{?epa\_recoil}, \ttt{?epa\_keep\_energy})'))
     call var_list%append_log (var_str ("?epa_recoil"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag to switch on recoil, i.e. a non-vanishing ' // &
           '$p_T$-kick for the equivalent-photon approximation (EPA).  ' // &
           '(cf. also \ttt{epa}, \ttt{epa\_x\_min}, \ttt{epa\_mass}, \ttt{epa\_alpha}, ' // &
           '\ttt{epa\_e\_max}, \ttt{epa\_q\_min}, \ttt{?epa\_keep\_energy})'))
     call var_list%append_log (var_str ("?epa_keep_energy"), .false., &
           intrinsic=.true., &
           description=var_str ('As the splitting kinematics for the EPA ' // &
           'structure function violates Lorentz invariance when the recoil ' // &
           'is switched on, this flag forces energy conservation when set ' // &
           'to true, otherwise violating energy conservation. (cf. also ' // &
           '\ttt{epa}, \ttt{epa\_x\_min}, \ttt{epa\_mass}, \ttt{epa\_alpha}, ' // &
           '\ttt{epa\_q\_min}, \ttt{?epa\_recoil})'))
     call var_list%append_log (var_str ("?epa_handler"), .false., &
           intrinsic=.true., &
           description=var_str ('Activate EPA ' // &
           'handler for event generation (no effect on integration). ' // &
           'Requires \ttt{epa\_recoil = false}'))
     call var_list%append_string (var_str ("$epa_handler_mode"), &
           var_str ("trivial"), &
           intrinsic=.true., &
           description=var_str ('Operation mode for the EPA ' // &
           'event handler.  Allowed values: \ttt{trivial} (no effect), ' // &
           '\ttt{recoil} (recoil kinematics with two beams)'))
     call var_list%append_real (var_str ("ewa_x_min"), 0._default, &
           intrinsic=.true., &
           description=var_str ('Real parameter that sets the lower cutoff ' // &
           'for the energy fraction in the splitting for the equivalent ' // &
           '$W$ approximation (EWA). This parameter has to be set by the ' // &
           'user to a non-zero value smaller than one. (cf. also \ttt{ewa}, ' // &
           '\ttt{ewa\_pt\_max}, \ttt{ewa\_mass}, \ttt{?ewa\_keep\_energy}, ' // &
           '\ttt{?ewa\_recoil})'))
     call var_list%append_real (var_str ("ewa_pt_max"), 0._default, &
           intrinsic=.true., &
           description=var_str ('This real parameter allows to set the ' // &
           'upper $p_T$ cutoff for the equivalent $W$ approximation (EWA). ' // &
           'If not set, \whizard\ simply takes the collider energy, $\sqrt{s}$. ' // &
           '(cf. also \ttt{ewa}, \ttt{ewa\_x\_min}, \ttt{ewa\_mass}, \ttt{?ewa\_keep\_energy}, ' // &
           '\ttt{?ewa\_recoil})'))
     call var_list%append_real (var_str ("ewa_mass"), 0._default, &
           intrinsic=.true., &
           description=var_str ('This real parameter allows to set by hand ' // &
           'the mass of the incoming particle for the equivalent $W$ approximation ' // &
           '(EWA). If not set, the mass for the initial beam particle is ' // &
           'taken from the model in use. (cf. also \ttt{ewa}, \ttt{ewa\_x\_min}, ' // &
           '\ttt{ewa\_pt\_max}, \ttt{?ewa\_keep\_energy}, \ttt{?ewa\_recoil})'))
     call var_list%append_log (var_str ("?ewa_recoil"), .false., &
          intrinsic=.true., &
          description=var_str ('For the equivalent $W$ approximation (EWA), ' // &
          'this flag switches on recoil, i.e. non-collinear splitting.  ' // &
          '(cf. also \ttt{ewa}, \ttt{ewa\_x\_min}, \ttt{ewa\_pt\_max},  ' // &
          '\ttt{ewa\_mass}, \ttt{?ewa\_keep\_energy})'))
     call var_list%append_log (var_str ("?ewa_keep_energy"), .false., &
           intrinsic=.true., &
           description=var_str ('As the splitting kinematics for the equivalent ' // &
           '$W$ approximation (EWA) violates Lorentz invariance when the ' // &
           'recoil is switched on, this flag forces energy conservation ' // &
           'when set to true, otherwise violating energy conservation. ' // &
           '(cf. also \ttt{ewa}, \ttt{ewa\_x\_min}, \ttt{ewa\_pt\_max},  ' // &
           '\ttt{ewa\_mass}, \ttt{?ewa\_recoil})'))
     call var_list%append_log (var_str ("?circe1_photon1"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag to tell \whizard\ to use the photon ' // &
           'of the \circeone\ beamstrahlung structure function as initiator ' // &
           'for the hard scattering process in the first beam. (cf. also ' // &
           '\ttt{circe1}, \ttt{?circe1\_photon2}, \ttt{circe1\_sqrts},  ' // &
           '\ttt{?circe1\_generate}, \ttt{?circe1\_map}, \ttt{circe1\_eps}, ' // &
           '\newline \ttt{circe1\_mapping\_slope}, \ttt{circe1\_ver}, ' // &
           '\ttt{circe1\_rev}, \ttt{\$circe1\_acc}, \ttt{circe1\_chat}, \newline' // &
           '\ttt{?circe1\_with\_radiation})'))
     call var_list%append_log (var_str ("?circe1_photon2"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag to tell \whizard\ to use the photon ' // &
           'of the \circeone\ beamstrahlung structure function as initiator ' // &
           'for the hard scattering process in the second beam. (cf. also ' // &
           '\ttt{circe1}, \ttt{?circe1\_photon1}, \ttt{circe1\_sqrts},  ' // &
           '\ttt{?circe1\_generate}, \ttt{?circe1\_map}, \ttt{circe1\_eps}, ' // &
           '\newline \ttt{circe1\_mapping\_slope}, \ttt{circe1\_ver}, ' // &
           '\ttt{circe1\_rev}, \ttt{\$circe1\_acc}, \ttt{circe1\_chat}, ' // &
           '\newline\ttt{?circe1\_with\_radiation})'))
     call var_list%append_real (var_str ("circe1_sqrts"), &
           intrinsic=.true., &
           description=var_str ('Real parameter that allows to set the ' // &
           'value of the collider energy for the lepton collider beamstrahlung ' // &
           'structure function \circeone. If not set, $\sqrt{s}$ is taken. ' // &
           '(cf. also \ttt{circe1}, \ttt{?circe1\_photon1}, \ttt{?circe1\_photon2},  ' // &
           '\ttt{?circe1\_generate}, \ttt{?circe1\_map}, \ttt{circe1\_eps}, ' // &
           '\newline \ttt{circe1\_mapping\_slope}, \ttt{circe1\_ver}, ' // &
           '\ttt{circe1\_rev}, \ttt{\$circe1\_acc}, \ttt{circe1\_chat}, \newline' // &
           '\ttt{?circe1\_with\_radiation})'))
     call var_list%append_log (var_str ("?circe1_generate"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that determines whether the \circeone\ ' // &
           'structure function for lepton collider beamstrahlung uses the ' // &
           'generator mode for the spectrum, or a pre-defined (semi-)analytical ' // &
           'parameterization. Default is the generator mode. (cf. also ' // &
           '\ttt{circe1}, \ttt{?circe1\_photon1}, \newline \ttt{?circe1\_photon2},  ' // &
           '\ttt{circe1\_sqrts}, \ttt{?circe1\_map}, \ttt{circe1\_mapping\_slope}, ' // &
           '\ttt{circe1\_eps}, \newline \ttt{circe1\_ver}, \ttt{circe1\_rev}, ' // &
           '\ttt{\$circe1\_acc}, \ttt{circe1\_chat}, \ttt{?circe1\_with\_radiation})'))
     call var_list%append_log (var_str ("?circe1_map"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that determines whether the \circeone\ ' // &
           'structure function for lepton collider beamstrahlung uses special ' // &
           'mappings for $s$-channel resonances. (cf. also \ttt{circe1}, ' // &
           '\ttt{?circe1\_photon1}, \newline \ttt{?circe1\_photon2},  ' // &
           '\ttt{circe1\_sqrts}, \ttt{?circe1\_generate}, ' // &
           '\ttt{circe1\_mapping\_slope}, \ttt{circe1\_eps}, \newline ' // &
           '\ttt{circe1\_ver}, \ttt{circe1\_rev}, \ttt{\$circe1\_acc}, ' // &
           '\ttt{circe1\_chat}, \ttt{?circe1\_with\_radiation})'))
     call var_list%append_real (var_str ("circe1_mapping_slope"), 2._default, &
           intrinsic=.true., &
           description=var_str ('Real parameter that allows to vary the ' // &
           'slope of the mapping function for the \circeone\ structure ' // &
           'function for lepton collider beamstrahlung from the default ' // &
           'value \ttt{2.}. (cf. also \ttt{circe1}, \ttt{?circe1\_photon1}, ' // &
           '\ttt{?circe1\_photon2}, \ttt{circe1\_sqrts},  \ttt{?circe1\_generate}, ' // &
           '\ttt{?circe1\_map}, \ttt{circe1\_eps}, \ttt{circe1\_ver}, ' // &
           '\ttt{circe1\_rev}, \ttt{\$circe1\_acc}, \ttt{circe1\_chat}, \newline' // &
           '\ttt{?circe1\_with\_radiation})'))
     call var_list%append_real (var_str ("circe1_eps"), 1e-5_default, &
           intrinsic=.true., &
           description=var_str ('Real parameter, that takes care of the ' // &
           'mapping of the peak in the lepton collider beamstrahlung structure ' // &
           'function spectrum of \circeone.  (cf. also \ttt{circe1}, \ttt{?circe1\_photons}, ' // &
           '\ttt{?circe1\_photon2}, \ttt{circe1\_sqrts}, \ttt{?circe1\_generate}, ' // &
           '\ttt{?circe1\_map}, \ttt{circe1\_eps}, \newline ' // &
           '\ttt{circe1\_mapping\_slope}, \ttt{circe1\_ver}, \ttt{circe1\_rev}, ' // &
           '\ttt{\$circe1\_acc}, \ttt{circe1\_chat}, \newline\ttt{?circe1\_with\_radiation})'))
     call var_list%append_int (var_str ("circe1_ver"), 0, intrinsic=.true., &
          description=var_str ('Integer parameter that sets the internal ' // &
          'versioning number of the \circeone\ structure function for lepton-collider ' // &
          'beamstrahlung. It has to be set by the user explicitly, it takes ' // &
          'values from one to ten.  (cf. also \ttt{circe1}, \ttt{?circe1\_photon1}, ' // &
          '\ttt{?circe1\_photon2},  \ttt{?circe1\_generate}, \ttt{?circe1\_map}, ' // &
          '\ttt{circe1\_eps}, \ttt{circe1\_mapping\_slope}, \ttt{circe1\_sqrts}, ' // &
          '\ttt{circe1\_rev}, \ttt{\$circe1\_acc}, \ttt{circe1\_chat}, ' // &
          '\ttt{?circe1\_with\_radiation})'))
     call var_list%append_int (var_str ("circe1_rev"), 0, intrinsic=.true., &
          description=var_str ('Integer parameter that sets the internal ' // &
          'revision number of the \circeone\ structure function for lepton-collider ' // &
          'beamstrahlung. The default \ttt{0} translates always into the ' // &
          'most recent version; older versions have to be accessed through ' // &
          'the explicit revision date. For more details cf.~the \circeone ' // &
          'manual.  (cf. also \ttt{circe1}, \ttt{?circe1\_photon1}, \ttt{?circe1\_photon2},  ' // &
          '\ttt{?circe1\_generate}, \ttt{?circe1\_map}, \ttt{circe1\_eps}, ' // &
          '\ttt{circe1\_mapping\_slope}, \ttt{circe1\_sqrts}, \ttt{circe1\_ver}, ' // &
          '\ttt{\$circe1\_acc}, \ttt{circe1\_chat}, \ttt{?circe1\_with\_radiation})'))
     call var_list%append_string (var_str ("$circe1_acc"), var_str ("SBAND"), &
           intrinsic=.true., &
           description=var_str ('String variable that specifies the accelerator ' // &
           'type for the \circeone\ structure function for lepton-collider ' // &
           'beamstrahlung.  (\ttt{?circe1\_photons}, \ttt{?circe1\_photon2}, ' // &
           '\ttt{circe1\_sqrts}, \ttt{?circe1\_generate}, \ttt{?circe1\_map}, ' // &
           '\ttt{circe1\_eps}, \ttt{circe1\_mapping\_slope}, \ttt{circe1\_ver}, ' // &
           '\newline \ttt{circe1\_rev}, \ttt{circe1\_chat}, \ttt{?circe1\_with\_radiation})'))
     call var_list%append_int (var_str ("circe1_chat"), 0, intrinsic=.true., &
          description=var_str ('Chattiness of the \circeone\ structure ' // &
          'function for lepton-collider beamstrahlung. The higher the integer ' // &
          'value, the more information will be given out by the \circeone\ ' // &
          'package. (\ttt{?circe1\_photons}, \ttt{?circe1\_photon2}, ' // &
          '\ttt{circe1\_sqrts}, \ttt{?circe1\_generate}, \ttt{?circe1\_map}, ' // &
          '\ttt{circe1\_eps}, \ttt{circe1\_mapping\_slope}, \ttt{circe1\_ver}, ' // &
          '\newline \ttt{circe1\_rev}, \ttt{\$circe1\_acc}, \ttt{?circe1\_with\_radiation})'))
     call var_list%append_log (var_str ("?circe1_with_radiation"), .false., &
          intrinsic=.true., &
          description=var_str ('This logical decides whether the additional photon ' // &
          'or electron ("beam remnant") will be considered in the event record or ' // &
          'not. (\ttt{?circe1\_photons}, \ttt{?circe1\_photon2}, ' // &
          '\ttt{circe1\_sqrts}, \ttt{?circe1\_generate}, \ttt{?circe1\_map}, ' // &
          '\ttt{circe1\_eps}, \ttt{circe1\_mapping\_slope}, \ttt{circe1\_ver}, ' // &
          '\newline \ttt{circe1\_rev}, \ttt{\$circe1\_acc})'))
     call var_list%append_log (var_str ("?circe2_polarized"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag whether the photon spectra from the ' // &
           '\circetwo\ structure function for lepton colliders should be ' // &
           'treated polarized. (cf. also \ttt{circe2}, \ttt{\$circe2\_file}, ' // &
           '\ttt{\$circe2\_design})'))
     call var_list%append_string (var_str ("$circe2_file"), &
           intrinsic=.true., &
           description=var_str ('String variable by which the corresponding ' // &
           'photon collider spectrum for the \circetwo\ structure function ' // &
           'can be selected. (cf. also \ttt{circe2}, \ttt{?circe2\_polarized}, ' // &
           '\ttt{\$circe2\_design})'))
     call var_list%append_string (var_str ("$circe2_design"), var_str ("*"), &
           intrinsic=.true., &
           description=var_str ('String variable that sets the collider ' // &
           'design for the \circetwo\ structure function for photon collider ' // &
           'spectra. (cf. also \ttt{circe2}, \ttt{\$circe2\_file}, \ttt{?circe2\_polarized})'))
     call var_list%append_real (var_str ("gaussian_spread1"), 0._default, &
           intrinsic=.true., &
           description=var_str ('Parameter that sets the energy spread ' // &
           '($\sigma$ value) of the first beam for a Gaussian spectrum.  ' // &
           '(cf. \ttt{gaussian})'))
      call var_list%append_real (var_str ("gaussian_spread2"), 0._default, &
           intrinsic=.true., &
           description=var_str ('Ditto, for the second beam.'))
     call var_list%append_string (var_str ("$beam_events_file"), &
           intrinsic=.true., &
           description=var_str ('String variable that allows to set the ' // &
           "name of the external file from which a beamstrahlung's spectrum " // &
           'for lepton colliders as pairs of energy fractions is read in. ' // &
           '(cf. also \ttt{beam\_events}, \ttt{?beam\_events\_warn\_eof})'))
     call var_list%append_log (var_str ("?beam_events_warn_eof"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that tells \whizard\ to ' // &
           'issue a warning when in a simulation the end of an external ' // &
           "file for beamstrahlung's spectra for lepton colliders are reached, " // &
           'and energy fractions from the beginning of the file are reused. ' // &
           '(cf. also \ttt{beam\_events}, \ttt{\$beam\_events\_file})'))
     call var_list%append_log (var_str ("?energy_scan_normalize"), .false., &
           intrinsic=.true., &
           description=var_str ('Normalization flag for the energy scan ' // &
           'structure function: if set the total cross section is normalized ' // &
           'to unity. (cf. also \ttt{energy\_scan})'))
   end subroutine var_list_set_beams_defaults
 
 @ %def var_list_set_beams_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_core_defaults => var_list_set_core_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_core_defaults (var_list, seed)
     class(var_list_t), intent(inout) :: var_list
     integer, intent(in) :: seed
     logical, target, save :: known = .true.     !!! ??????
     real(default), parameter :: real_specimen = 1.
     call var_list_append_log_ptr &
          (var_list, var_str ("?logging"), logging, known, &
          intrinsic=.true., &
          description=var_str ('This logical -- when set to \ttt{false} ' // &
          '-- suppresses writing out a logfile (default: \ttt{whizard.log}) ' // &
          'for the whole \whizard\ run, or when \whizard\ is run with the ' // &
          '\ttt{--no-logging} option, to suppress parts of the logging ' // &
          'when setting it to \ttt{true} again at a later part of the ' // &
          '\sindarin\ input file. Mainly for debugging purposes.  ' // &
          '(cf. also \ttt{?openmp\_logging}, \ttt{?mpi\_logging})'))
     call var_list%append_string (var_str ("$job_id"), &
          intrinsic=.true., &
          description=var_str ('Arbitrary string that can be used for ' // &
          'creating unique names.  The variable is initialized with the ' // &
          'value of the \ttt{job\_id} option on startup. (cf. also ' // &
          '\ttt{\$compile\_workspace}, \ttt{\$run\_id})'))
     call var_list%append_string (var_str ("$compile_workspace"), &
          intrinsic=.true., &
          description=var_str ('If set, create process source code ' // &
          'and process-driver library code in a subdirectory with this ' // &
          'name.  If non-existent, the directory will be created. (cf. ' // &
          'also \ttt{\$job\_id}, \ttt{\$run\_id}, \ttt{\$integrate\_workspace})'))
     call var_list%append_int (var_str ("seed"), seed, &
           intrinsic=.true., &
           description=var_str ('Integer variable \ttt{seed = {\em <num>}} ' // &
           'that allows to set a specific random seed \ttt{num}. If not ' // &
           'set, \whizard\ takes the time from the system clock to determine ' // &
           'the random seed.'))
     call var_list%append_string (var_str ("$model_name"), &
           intrinsic=.true., &
           description=var_str ('This variable makes the locally used physics ' // &
           'model available as a string, e.g. as \ttt{show (\$model\_name)}. ' // &
           'However, the user is not able to change the current model by ' // &
           'setting this variable to a different string. (cf. also \ttt{model}, ' // &
           '\ttt{\$library\_name}, \ttt{printf}, \ttt{show})'))
     call var_list%append_int (var_str ("process_num_id"), &
          intrinsic=.true., &
          description=var_str ('Using the integer \ttt{process\_num\_id ' // &
          '= {\em <int\_var>}} one can set a numerical identifier for processes ' // &
          'within a process library. This can be set either just before ' // &
          'the corresponding \ttt{process} definition or as an optional ' // &
          'local argument of the latter. (cf. also \ttt{process})'))
     call var_list%append_string (var_str ("$method"), var_str ("omega"), &
          intrinsic=.true., &
          description=var_str ('This string variable specifies the method ' // &
          'for the matrix elements to be used in the evaluation. The default ' // &
          "is the intrinsic \oMega\ matrix element generator " // &
          '(\ttt{"omega"}), other options are: \ttt{"ovm"}, \ttt{"unit\_test"}, ' // &
          '\ttt{"template\_unity"}, \ttt{"threshold"}. For processes defined ' // &
          '\ttt{"template"}, with \ttt{nlo\_calculation = ...}, please refer to ' // &
          '\ttt{\$born\_me\_method}, \ttt{\$real\_tree\_me\_method}, ' // &
          '\ttt{\$loop\_me\_method} and \ttt{\$correlation\_me\_method}.'))
     call var_list%append_log (var_str ("?report_progress"), .true., &
          intrinsic=.true., &
          description=var_str ('Flag for the \oMega\ matrix element generator ' // &
          'whether to print out status messages about progress during ' // &
          'matrix element generation. (cf. also \ttt{\$method}, \ttt{\$omega\_flags})'))
     call var_list%append_log (var_str ("?me_verbose"), .false., &
          description=var_str ("Flag determining whether " // &
          "the makefile command for generating and compiling the \oMega\ matrix " // &
          "element code is silent or verbose. Default is silent."))
     call var_list%append_string (var_str ("$restrictions"), var_str (""), &
          intrinsic=.true., &
          description=var_str ('This is an optional argument for process ' // &
          'definitions for the matrix element method \ttt{"omega"}. Using ' // &
          'the following construction, it defines a string variable, \ttt{process ' // &
          '\newline {\em <process\_name>} = {\em <particle1>}, {\em <particle2>} ' // &
          '=> {\em <particle3>}, {\em <particle4>}, ... \{ \$restrictions ' // &
          '= "{\em <restriction\_def>}" \}}. The string argument \ttt{{\em ' // &
          '<restriction\_def>}} is directly transferred during the code ' // &
          'generation to the ME generator \oMega. It has to be of the form ' // &
          '\ttt{n1 + n2 + ...  \url{~} {\em <particle (list)>}}, where ' // &
          '\ttt{n1} and so on are the numbers of the particles above in ' // &
          'the process definition. The tilde specifies a certain intermediate ' // &
          'state to be equal to the particle(s) in \ttt{particle (list)}. ' // &
          'An example is \ttt{process eemm\_z =     e1, E1  =>  e2, E2 ' // &
          '\{ \$restrictions = "1+2 \url{~} Z" \} } restricts the code ' // &
          'to be generated for the process $e^- e^+ \to \mu^- \mu^+$ to ' // &
          'the $s$-channel $Z$-boson exchange. For more details see Sec.~\ref{sec:omega_me} ' // &
          '(cf. also \ttt{process})'))
     call var_list%append_log (var_str ("?omega_write_phs_output"), .false., &
          intrinsic=.true., &
          description=var_str ('This flag decides whether a the phase-space ' // &
          'output is produced by the \oMega\ matrix element generator. This ' // &
          'output is written to file(s) and contains the Feynman diagrams ' // &
          'which belong to the process(es) under consideration. The file is ' // &
          'mandatory whenever the variable \ttt{\$phs\_method} has the value ' // &
          '\ttt{fast\_wood}, i.e. if the phase-space file is provided by ' // &
          'cascades2.'))
     call var_list%append_string (var_str ("$omega_flags"), var_str (""), &
          intrinsic=.true., &
          description=var_str ('String variable that allows to pass flags ' // &
          'to the \oMega\ matrix element generator. Normally, \whizard\ ' // &
          'takes care of all flags automatically. Note that for restrictions ' // &
          'of intermediate states, there is a special string variable: ' // &
          '(cf. $\to$) \ttt{\$restrictions}.'))
     call var_list%append_log (var_str ("?read_color_factors"), .true., &
           intrinsic=.true., &
           description=var_str ('This flag decides whether to read QCD ' // &
           'color factors from the matrix element provided by each method, ' // &
           'or to try and calculate the color factors in \whizard\ internally.'))
      !!! JRR: WK please check (#529)
 !     call var_list_append_string &
 !          (var_list, var_str ("$user_procs_cut"), var_str (""), &
 !           intrinsic=.true.)
 !     call var_list_append_string &
 !          (var_list, var_str ("$user_procs_event_shape"), var_str (""), &
 !           intrinsic=.true.)
 !     call var_list_append_string &
 !          (var_list, var_str ("$user_procs_obs1"), var_str (""), &
 !           intrinsic=.true.)
 !     call var_list_append_string &
 !          (var_list, var_str ("$user_procs_obs2"), var_str (""), &
 !           intrinsic=.true.)
 !     call var_list_append_string &
 !          (var_list, var_str ("$user_procs_sf"), var_str (""), &
 !           intrinsic=.true.)
     call var_list%append_log (var_str ("?slha_read_input"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag which decides whether \whizard\ reads ' // &
           'in the SM and parameter information from the \ttt{SMINPUTS} ' // &
           'and \ttt{MINPAR} common blocks of the SUSY Les Houches Accord ' // &
           'files. (cf. also \ttt{read\_slha}, \ttt{write\_slha}, \ttt{?slha\_read\_spectrum}, ' // &
           '\ttt{?slha\_read\_decays})'))
     call var_list%append_log (var_str ("?slha_read_spectrum"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag which decides whether \whizard\ reads ' // &
           'in the whole spectrum and mixing angle information from the ' // &
           'common blocks of the SUSY Les Houches Accord files. (cf. also ' // &
           '\ttt{read\_slha}, \ttt{write\_slha}, \ttt{?slha\_read\_decays}, ' // &
           '\ttt{?slha\_read\_input})'))
     call var_list%append_log (var_str ("?slha_read_decays"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag which decides whether \whizard\ reads ' // &
           'in the widths and branching ratios from the \ttt{DCINFO} common ' // &
           'block of the SUSY Les Houches Accord files. (cf. also \ttt{read\_slha}, ' // &
           '\ttt{write\_slha}, \ttt{?slha\_read\_spectrum}, \ttt{?slha\_read\_input})'))
     call var_list%append_string (var_str ("$library_name"), &
           intrinsic=.true., &
           description=var_str ('Similar to \ttt{\$model\_name}, this string ' // &
           'variable is used solely to access the name of the active process ' // &
           'library, e.g. in \ttt{printf} statements. (cf. \ttt{compile}, ' // &
           '\ttt{library}, \ttt{printf}, \ttt{show}, \ttt{\$model\_name})'))
     call var_list%append_log (var_str ("?alphas_is_fixed"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that tells \whizard\ to use a non-running ' // &
           '$\alpha_s$. Note that this has to be set explicitly to $\ttt{false}$ ' // &
           'if the user wants to use one of the running $\alpha_s$ options. ' // &
           '(cf. also \ttt{alphas\_order}, \ttt{?alphas\_from\_lhapdf}, ' // &
           '\ttt{?alphas\_from\_pdf\_builtin}, \ttt{alphas\_nf}, \ttt{?alphas\_from\_mz}, ' // &
           '\newline \ttt{?alphas\_from\_lambda\_qcd}, \ttt{lambda\_qcd})'))
     call var_list%append_log (var_str ("?alphas_from_lhapdf"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that tells \whizard\ to use a running ' // &
           '$\alpha_s$ from the \lhapdf\ library (which has to be correctly ' // &
           'linked). Note that \ttt{?alphas\_is\_fixed} has to be set ' // &
           'explicitly to $\ttt{false}$. (cf. also \ttt{alphas\_order}, ' // &
           '\ttt{?alphas\_is\_fixed}, \ttt{?alphas\_from\_pdf\_builtin}, ' // &
           '\ttt{alphas\_nf}, \ttt{?alphas\_from\_mz}, \ttt{?alphas\_from\_lambda\_qcd}, ' // &
           '\ttt{lambda\_qcd})'))
     call var_list%append_log (var_str ("?alphas_from_pdf_builtin"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that tells \whizard\ to use a running ' // &
           '$\alpha_s$ from the internal PDFs. Note that in that case \ttt{?alphas\_is\_fixed} ' // &
           'has to be set explicitly to $\ttt{false}$. (cf. also ' // &
           '\ttt{alphas\_order}, \ttt{?alphas\_is\_fixed}, \ttt{?alphas\_from\_lhapdf}, ' // &
           '\ttt{alphas\_nf}, \ttt{?alphas\_from\_mz}, \newline \ttt{?alphas\_from\_lambda\_qcd}, ' // &
           '\ttt{lambda\_qcd})'))
     call var_list%append_int (var_str ("alphas_order"), 0, &
           intrinsic=.true., &
           description=var_str ('Integer parameter that sets the order ' // &
           'of the internal evolution for running $\alpha_s$ in \whizard: ' // &
           'the default, \ttt{0}, is LO running, \ttt{1} is NLO, \ttt{2} ' // &
           'is NNLO. (cf. also \ttt{alphas\_is\_fixed}, \ttt{?alphas\_from\_lhapdf}, ' // &
           '\ttt{?alphas\_from\_pdf\_builtin}, \ttt{alphas\_nf}, \ttt{?alphas\_from\_mz}, ' // &
           '\newline \ttt{?alphas\_from\_lambda\_qcd}, \ttt{lambda\_qcd})'))
     call var_list%append_int (var_str ("alphas_nf"), 5, &
           intrinsic=.true., &
           description=var_str ('Integer parameter that sets the number ' // &
           'of active quark flavors for the internal evolution for running ' // &
           '$\alpha_s$ in \whizard: the default is \ttt{5}. (cf. also ' // &
           '\ttt{alphas\_is\_fixed}, \ttt{?alphas\_from\_lhapdf}, \ttt{?alphas\_from\_pdf\_builtin}, ' // &
           '\ttt{alphas\_order}, \ttt{?alphas\_from\_mz}, \newline ' // &
           '\ttt{?alphas\_from\_lambda\_qcd}, \ttt{lambda\_qcd})'))
     call var_list%append_log (var_str ("?alphas_from_mz"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that tells \whizard\ to use its internal ' // &
           'running $\alpha_s$ from $\alpha_s(M_Z)$. Note that in that ' // &
           'case \ttt{?alphas\_is\_fixed} has to be set explicitly to ' // &
           '$\ttt{false}$. (cf. also \ttt{alphas\_order}, \ttt{?alphas\_is\_fixed}, ' // &
           '\ttt{?alphas\_from\_lhapdf}, \ttt{alphas\_nf}, \ttt{?alphas\_from\_pdf\_builtin}, ' // &
           '\newline \ttt{?alphas\_from\_lambda\_qcd}, \ttt{lambda\_qcd})'))
     call var_list%append_log (var_str ("?alphas_from_lambda_qcd"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that tells \whizard\ to use its internal ' // &
           'running $\alpha_s$ from $\alpha_s(\Lambda_{QCD})$. Note that ' // &
           'in that case \ttt{?alphas\_is\_fixed} has  to be set explicitly ' // &
           'to $\ttt{false}$. (cf. also \ttt{alphas\_order}, \ttt{?alphas\_is\_fixed}, ' // &
           '\ttt{?alphas\_from\_lhapdf}, \ttt{alphas\_nf}, \ttt{?alphas\_from\_pdf\_builtin}, ' // &
           '\newline \ttt{?alphas\_from\_mz}, \ttt{lambda\_qcd})'))
     call var_list%append_real (var_str ("lambda_qcd"), 200.e-3_default, &
           intrinsic=.true., &
           description=var_str ('Real parameter that sets the value for ' // &
           '$\Lambda_{QCD}$ used in the internal evolution for running ' // &
           '$\alpha_s$ in \whizard. (cf. also \ttt{alphas\_is\_fixed}, ' // &
           '\ttt{?alphas\_from\_lhapdf}, \ttt{alphas\_nf}, ' // &
           '\newline \ttt{?alphas\_from\_pdf\_builtin}, ' // &
           '\ttt{?alphas\_from\_mz}, \ttt{?alphas\_from\_lambda\_qcd}, ' // &
           '\ttt{alphas\_order})'))
     call var_list%append_log (var_str ("?fatal_beam_decay"), .true., &
           intrinsic=.true., &
           description=var_str ('Logical variable that let the user decide ' // &
           'whether the possibility of a beam decay is treated as a fatal ' // &
           'error or only as a warning. An example is a process $b t \to ' // &
           'X$, where the bottom quark as an inital state particle appears ' // &
           'as a possible decay product of the second incoming particle, ' // &
           'the top quark. This might trigger inconsistencies or instabilities ' // &
           'in the phase space set-up.'))
     call var_list%append_log (var_str ("?helicity_selection_active"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whether \whizard\ uses ' // &
           'a numerical selection rule for vanishing helicities: if active, ' // &
           'then, if a certain helicity combination yields an absolute ' // &
           '(\oMega) matrix element smaller than a certain threshold ($\to$ ' // &
           '\ttt{helicity\_selection\_threshold}) more often than a certain ' // &
           'cutoff ($\to$ \ttt{helicity\_selection\_cutoff}), it will be dropped.'))
     call var_list%append_real (var_str ("helicity_selection_threshold"), &
           1E10_default, &
           intrinsic=.true., &
           description=var_str ('Real parameter that gives the threshold ' // &
           'for the absolute value of a certain helicity combination of ' // &
           'an (\oMega) amplitude. If a certain number ($\to$ ' // &
           '\ttt{helicity\_selection\_cutoff}) of calls stays below this ' // &
           'threshold, that combination will be dropped from then on. (cf. ' // &
           'also \ttt{?helicity\_selection\_active})'))
     call var_list%append_int (var_str ("helicity_selection_cutoff"), 1000, &
           intrinsic=.true., &
           description=var_str ('Integer parameter that gives the number ' // &
           "a certain helicity combination of an (\oMega) amplitude has " // &
           'to be below a certain threshold ($\to$ \ttt{helicity\_selection\_threshold}) ' // &
           'in order to be dropped from then on. (cf. also \ttt{?helicity\_selection\_active})'))
     call var_list%append_string (var_str ("$rng_method"), var_str ("tao"), &
           intrinsic=.true., &
           description=var_str ('String variable that allows to set the ' // &
           'method for the random number generation. Default is Donald ' // &
           "Knuth' RNG method \ttt{TAO}."))
     call var_list%append_log (var_str ("?vis_diags"), .false., &
           intrinsic=.true., &
           description=var_str ('Logical variable that allows to give out ' // &
           "a Postscript or PDF file for the Feynman diagrams for a \oMega\ " // &
           'process.  (cf. \ttt{?vis\_diags\_color}).'))
     call var_list%append_log (var_str ("?vis_diags_color"), .false., &
           intrinsic=.true., &
           description=var_str ('Same as \ttt{?vis\_diags}, but switches ' // &
           'on color flow instead of Feynman diagram generation. (cf. \ttt{?vis\_diags}).'))
     call var_list%append_log (var_str ("?check_event_file"), .true., &
           intrinsic=.true., &
           description=var_str ('Setting this to false turns off all sanity ' // &
           'checks when reading a raw event file with previously generated ' // &
           'events.  Use this at your own risk; the program may return ' // &
           'wrong results or crash if data do not match. (cf. also \ttt{?check\_grid\_file}, ' // &
           '\ttt{?check\_phs\_file})'))
     call var_list%append_string (var_str ("$event_file_version"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('String variable that allows to set the ' // &
           'format version of the \whizard\ internal binary event format.'))
     call var_list%append_int (var_str ("n_events"), 0, &
           intrinsic=.true., &
           description=var_str ('This specifier \ttt{n\_events = {\em <num>}} ' // &
           'sets the number of events for the event generation of the processes ' // &
           'in the \sindarin\ input files. Note that WHIZARD itself chooses ' // &
           'the number from the \ttt{n\_events} or from the \ttt{luminosity} ' // &
           'specifier, whichever would give the larger number of events. ' // &
           'As this depends on the cross section under consideration, it ' // &
           'might be different for different processes in the process list.  ' // &
           '(cf. \ttt{luminosity}, \ttt{\$sample}, \ttt{sample\_format}, ' // &
           '\ttt{?unweighted}, \ttt{event\_index\_offset})'))
     call var_list%append_int (var_str ("event_index_offset"), 0, &
           intrinsic=.true., &
           description=var_str ('The value ' // &
           '\ttt{event\_index\_offset = {\em <num>}} ' // &
           'initializes the event counter for a subsequent ' // &
           'event sample.  By default (value 0), the first event ' // &
           'gets index value 1, incrementing by one for each generated event ' // &
           'within a sample.  The event counter is initialized again ' // &
           'for each new sample (i.e., \ttt{integrate} command). ' // &
           'If events are read from file, and the ' // &
           'event file format supports event numbering, the event numbers ' // &
           'will be taken from file instead, and the value of ' // &
           '\ttt{event\_index\_offset} has no effect. ' // &
           '(cf. \ttt{luminosity}, \ttt{\$sample}, \ttt{sample\_format}, ' // &
           '\ttt{?unweighted}, \ttt{n\_events})'))
     call var_list%append_log (var_str ("?unweighted"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that distinguishes between unweighted ' // &
           'and weighted event generation. (cf. also \ttt{simulate}, \ttt{n\_events}, ' // &
           '\ttt{luminosity}, \ttt{event\_index\_offset})'))
     call var_list%append_real (var_str ("safety_factor"), 1._default, &
           intrinsic=.true., &
           description=var_str ('This real variable \ttt{safety\_factor ' // &
           '= {\em <num>}} reduces the acceptance probability for unweighting.  ' // &
           'If greater than one, excess events become less likely, but ' // &
           'the reweighting efficiency also drops. (cf. \ttt{simulate}, \ttt{?unweighted})'))
     call var_list%append_log (var_str ("?negative_weights"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that tells \whizard\ to allow negative ' // &
           'weights in integration and simulation. (cf. also \ttt{simulate}, ' // &
           '\ttt{?unweighted})'))
     call var_list%append_log (var_str ("?resonance_history"), .false., &
           intrinsic=.true., &
           description=var_str ( &
           'The logical variable \texttt{?resonance\_history ' // &
           '= true/false} specifies whether during a simulation pass, ' // &
           'the event generator should try to reconstruct intermediate ' // &
           'resonances.  If activated, appropriate resonant subprocess ' // &
           'matrix element code will be automatically generated. '))
     call var_list%append_real (var_str ("resonance_on_shell_limit"), &
           4._default, &
           intrinsic=.true., &
           description=var_str ( &
           'The real variable \texttt{resonance\_on\_shell\_limit ' // &
           '= {\em <num>}} specifies the maximum relative distance from a ' // &
           'resonance peak, such that the kinematical configuration ' // &
           'can still be considered on-shell.  This is relevant only if ' // &
           '\texttt{?resonance\_history = true}.'))
     call var_list%append_real (var_str ("resonance_on_shell_turnoff"), &
           0._default, &
           intrinsic=.true., &
           description=var_str ( &
           'The real variable \texttt{resonance\_on\_shell\_turnoff ' // &
           '= {\em <num>}}, if positive, ' // &
           'controls the smooth transition from resonance-like ' // &
           'to background-like events.  The relative strength of a ' // &
           'resonance is reduced by a Gaussian with width given by this ' // &
           'variable.  In any case, events are treated as background-like ' // &
           'when the off-shellness is greater than ' // &
           '\texttt{resonance\_on\_shell\_limit}.  All of this applies ' // &
           'only if \texttt{?resonance\_history = true}.'))
     call var_list%append_real (var_str ("resonance_background_factor"), &
           1._default, &
           intrinsic=.true., &
           description=var_str ( &
           'The real variable \texttt{resonance\_background\_factor} ' // &
           'controls resonance insertion if a resonance ' // &
           'history applies to a particular event.  In determining '// &
           'whether event kinematics qualifies as resonant or non-resonant, ' //&
           'the non-resonant probability is multiplied by this factor ' // &
           'Setting the factor to zero removes the background ' // &
           'configuration as long as the kinematics qualifies as on-shell ' // &
           'as qualified by \texttt{resonance\_on\_shell\_limit}.'))
      call var_list%append_log (var_str ("?keep_beams"), .false., &
           intrinsic=.true., &
           description=var_str ('The logical variable \ttt{?keep\_beams ' // &
           '= true/false} specifies whether beam particles and beam remnants ' // &
           'are included when writing event files.  For example, in order ' // &
           'to read Les Houches accord event files into \pythia, no beam ' // &
           'particles are allowed.'))
     call var_list%append_log (var_str ("?keep_remnants"), .true., &
           intrinsic=.true., &
           description=var_str ('The logical variable \ttt{?keep\_beams ' // &
           '= true/false} is respected only if \ttt{?keep\_beams} is set.  ' // &
           'If \ttt{true}, beam remnants are tagged as outgoing particles ' // &
           'if they have been neither showered nor hadronized, i.e., have ' // &
           'no children.  If \ttt{false}, beam remnants are also included ' // &
           'in the event record, but tagged as unphysical.  Note that for ' // &
           'ISR and/or beamstrahlung spectra, the radiated photons are ' // &
           'considered as beam remnants.'))
     call var_list%append_log (var_str ("?recover_beams"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whether the beam particles ' // &
           'should be reconstructed when reading event/rescanning files ' // &
           'into \whizard. (cf. \ttt{rescan}, \ttt{?update\_event}, \ttt{?update\_sqme}, ' // &
           '\newline \ttt{?update\_weight})'))
     call var_list%append_log (var_str ("?update_event"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whether the events in ' // &
           'an event file should be rebuilt from the hard process when ' // &
           'reading event/rescanning files into \whizard. (cf. \ttt{rescan}, ' // &
           '\ttt{?recover\_beams}, \ttt{?update\_sqme}, \ttt{?update\_weight})'))
     call var_list%append_log (var_str ("?update_sqme"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whehter the squared ' // &
           'matrix element in an event file should be updated/recalculated ' // &
           'when reading event/rescanning files into \whizard. (cf. \ttt{rescan}, ' // &
           '\newline \ttt{?recover\_beams}, \ttt{?update\_event}, \ttt{?update\_weight})'))
     call var_list%append_log (var_str ("?update_weight"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whether the weights ' // &
           'in an event file should be updated/recalculated when reading ' // &
           'event/rescanning files into \whizard. (cf. \ttt{rescan}, \ttt{?recover\_beams}, ' // &
           '\newline \ttt{?update\_event}, \ttt{?update\_sqme})'))
     call var_list%append_log (var_str ("?use_alphas_from_file"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whether the current ' // &
           '$\alpha_s$ definition should be used when recalculating matrix ' // &
           'elements for events read from file, or the value that is stored ' // &
           'in the file for that event. (cf. \ttt{rescan}, \ttt{?update\_sqme}, ' // &
           '\ttt{?use\_scale\_from\_file})'))
     call var_list%append_log (var_str ("?use_scale_from_file"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whether the current ' // &
           'energy-scale expression should be used when recalculating matrix ' // &
           'elements for events read from file, or the value that is stored ' // &
           'in the file for that event. (cf. \ttt{rescan}, \ttt{?update\_sqme}, ' // &
           '\ttt{?use\_alphas\_from\_file})'))
     call var_list%append_log (var_str ("?allow_decays"), .true., &
           intrinsic=.true., &
           description=var_str ('Master flag to switch on cascade decays ' // &
           'for final state particles as an event transform. As a default, ' // &
           'it is switched on. (cf. also \ttt{?auto\_decays}, ' // &
           '\ttt{auto\_decays\_multiplicity}, \ttt{?auto\_decays\_radiative}, ' // &
           '\ttt{?decay\_rest\_frame})'))
     call var_list%append_log (var_str ("?auto_decays"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag, particularly as optional argument of the ($\to$) ' // &
           '\ttt{unstable} command, that tells \whizard\ to automatically ' // &
           'determine the decays of that particle up to the final state ' // &
           'multplicity ($\to$) \ttt{auto\_decays\_multiplicity}. Depending ' // &
           'on the flag ($\to$) \ttt{?auto\_decays\_radiative}, radiative ' // &
           'decays will be taken into account or not. (cf. also \ttt{unstable}, ' // &
           '\ttt{?isotropic\_decay}, \ttt{?diagonal\_decay})'))
     call var_list%append_int (var_str ("auto_decays_multiplicity"), 2, &
           intrinsic=.true., &
           description=var_str ('Integer parameter, that sets -- ' // &
           'for the ($\to$) \ttt{?auto\_decays} option to let \whizard\ ' // &
           'automatically determine the decays of a particle set as ($\to$) ' // &
           '\ttt{unstable} -- the maximal final state multiplicity that ' // &
           'is taken into account. The default is \ttt{2}. The flag \ttt{?auto\_decays\_radiative} ' // &
           'decides whether radiative decays are taken into account. (cf.\ ' // &
           'also \ttt{unstable}, \ttt{?auto\_decays})'))
     call var_list%append_log (var_str ("?auto_decays_radiative"), .false., &
           intrinsic=.true., &
           description=var_str ("If \whizard's automatic detection " // &
           'of decay channels are switched on ($\to$ \ttt{?auto\_decays} ' // &
           'for the ($\to$) \ttt{unstable} command, this flags decides ' // &
           'whether radiative decays (e.g. containing additional photon(s)/gluon(s)) ' // &
           'are taken into account or not. (cf. also \ttt{unstable}, \ttt{auto\_decays\_multiplicity})'))
     call var_list%append_log (var_str ("?decay_rest_frame"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that allows to force a particle decay ' // &
           'to be simulated in its rest frame.  This simplifies the calculation ' // &
           'for decays as stand-alone processes, but makes the process ' // &
           'unsuitable for use in a decay chain.'))
     call var_list%append_log (var_str ("?isotropic_decay"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that -- in case of using factorized ' // &
           'production and decays using the ($\to$) \ttt{unstable} command ' // &
           '-- tells \whizard\ to switch off spin correlations completely ' // &
           '(isotropic decay). (cf. also \ttt{unstable}, \ttt{?auto\_decays}, ' // &
           '\ttt{decay\_helicity}, \ttt{?diagonal\_decay})'))
     call var_list%append_log (var_str ("?diagonal_decay"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that -- in case of using factorized ' // &
           'production and decays using the ($\to$) \ttt{unstable} command ' // &
           '-- tells \whizard\ instead of full spin correlations to take ' // &
           'only the diagonal entries in the spin-density matrix (i.e. ' // &
           'classical spin correlations). (cf. also \ttt{unstable}, \ttt{?auto\_decays}, ' // &
           '\ttt{decay\_helicity}, \ttt{?isotropic\_decay})'))
     call var_list%append_int (var_str ("decay_helicity"), &
           intrinsic=.true., &
           description=var_str ('If this parameter is given an integer ' // &
           'value, any particle decay triggered by a subsequent \ttt{unstable} ' // &
           'declaration will receive a projection on the given helicity ' // &
           'state for the unstable particle.  (cf. also \ttt{unstable}, ' // &
           '\ttt{?isotropic\_decay}, \ttt{?diagonal\_decay}.  The latter ' // &
           'parameters, if true, take precdence over any \ttt{?decay\_helicity} setting.)'))
     call var_list%append_log (var_str ("?polarized_events"), .false., &
             intrinsic=.true., &
             description=var_str ('Flag that allows to select certain helicity ' // &
             'combinations in final state particles in the event files, ' // &
             'and perform analysis on polarized event samples. (cf. also ' // &
             '\ttt{simulate}, \ttt{polarized}, \ttt{unpolarized})'))
     call var_list%append_string (var_str ("$polarization_mode"), &
          var_str ("helicity"), &
          intrinsic=.true., &
          description=var_str ('String variable that specifies the mode in ' // &
          'which the polarization of particles is handled when polarized events ' // &
          'are written out. Possible options are \ttt{"ignore"}, \ttt{"helicity"}, ' // &
          '\ttt{"factorized"}, and \ttt{"correlated"}. For more details cf. the ' // &
          'detailed section.'))
+    call var_list%append_log (var_str ("?colorize_subevt"), .false., &
+            intrinsic=.true., &
+            description=var_str ('Flag that enables color-index tracking ' // &
+            'in the subevent (\ttt{subevt}) objects that are used for ' // &
+            'internal event analysis.'))
     call var_list%append_real (var_str ("tolerance"), 0._default, &
           intrinsic=.true., &
           description=var_str ('Real variable that defines the absolute ' // &
           'tolerance with which the (logical) function \ttt{expect} accepts ' // &
           'equality or inequality: \ttt{tolerance = {\em <num>}}. This ' // &
           'can e.g. be used for cross-section tests and backwards compatibility ' // &
           'checks.  (cf. also \ttt{expect})'))
     call var_list%append_int (var_str ("checkpoint"), 0, &
          intrinsic = .true., &
          description=var_str ('Setting this integer variable to a positive ' // &
          'integer $n$ instructs simulate to print out a progress summary ' // &
          'every $n$ events.'))
     call var_list%append_int (var_str ("event_callback_interval"), 0, &
          intrinsic = .true., &
          description=var_str ('Setting this integer variable to a positive ' // &
          'integer $n$ instructs simulate to print out a progress summary ' // &
          'every $n$ events.'))
     call var_list%append_log (var_str ("?pacify"), .false., &
          intrinsic=.true., &
          description=var_str ('Flag that allows to suppress numerical ' // &
          'noise and give screen and log file output with a lower number ' // &
          'of significant digits. Mainly for debugging purposes. (cf. also ' // &
          '\ttt{?sample\_pacify})'))
     call var_list%append_string (var_str ("$out_file"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('This character variable allows to specify ' // &
           'the name of the data file to which the histogram and plot data ' // &
           'are written (cf. also \ttt{write\_analysis}, \ttt{open\_out}, ' // &
           '\ttt{close\_out})'))
     call var_list%append_log (var_str ("?out_advance"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that sets advancing in the \ttt{printf} ' // &
           'output commands, i.e. continuous printing with no line feed ' // &
           'etc. (cf. also \ttt{printf})'))
      !!! JRR: WK please check (#542)
 !     call var_list%append_log (var_str ("?out_custom"), .false., &
 !           intrinsic=.true.)
 !     call var_list%append_string (var_str ("$out_comment"), var_str ("# "), &
 !           intrinsic=.true.)
 !     call var_list%append_log (var_str ("?out_header"), .true., &
 !           intrinsic=.true.)
 !     call var_list%append_log (var_str ("?out_yerr"), .true., &
 !           intrinsic=.true.)
 !     call var_list%append_log (var_str ("?out_xerr"), .true., &
 !           intrinsic=.true.)
     call var_list%append_int (var_str ("real_range"), &
          range (real_specimen), intrinsic = .true., locked = .true., &
          description=var_str ('This integer gives the decimal exponent ' // &
          'range of the numeric model for the real float type in use. It cannot ' // & 
          'be set by the user. (cf. also \ttt{real\_precision}, ' // &
          '\ttt{real\_epsilon}, \ttt{real\_tiny}).'))
     call var_list%append_int (var_str ("real_precision"), &
          precision (real_specimen), intrinsic = .true., locked = .true., &
          description=var_str ('This integer gives the precision of ' // &
          'the numeric model for the real float type in use. It cannot ' // & 
          'be set by the user. (cf. also \ttt{real\_range}, ' // &
          '\ttt{real\_epsilon}, \ttt{real\_tiny}).'))
     call var_list%append_real (var_str ("real_epsilon"), &
          epsilon (real_specimen), intrinsic = .true., locked = .true., &
          description=var_str ('This gives the smallest number $E$ ' // &
          'of the same kind as the float type for which $1 + E > 1$. ' // & 
          'It cannot be set by the user. (cf. also \ttt{real\_range}, ' // &
          '\ttt{real\_tiny}, \ttt{real\_precision}).'))
     call var_list%append_real (var_str ("real_tiny"), &
          tiny (real_specimen), intrinsic = .true., locked = .true., &
          description=var_str ('This gives the smallest positive (non-zero) ' // &
          'number in the numeric model for the real float type in use. ' // & 
          'It cannot be set by the user. (cf. also \ttt{real\_range}, ' // &
          '\ttt{real\_epsilon}, \ttt{real\_precision}).'))
   end subroutine var_list_set_core_defaults
 
 @ %def var_list_set_core_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_integration_defaults => var_list_set_integration_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_integration_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_string (var_str ("$integration_method"), var_str ("vamp"), &
           intrinsic=.true., &
           description=var_str ('This string variable specifies the method ' // &
           'for performing the multi-dimensional phase-space integration. ' // &
           'The default is the \vamp\ algorithm (\ttt{"vamp"}), other options ' // &
           'are via the numerical midpoint rule (\ttt{"midpoint"}) or an ' // &
           'alternate \vamptwo\ implementation that is MPI-parallelizable ' // &
           '(\ttt{"vamp2"}).'))
     call var_list%append_int (var_str ("threshold_calls"), 10, &
           intrinsic=.true., &
           description=var_str ('This integer variable gives a limit for ' // &
           'the number of calls in a given channel which acts as a lower ' // &
           'threshold for the channel weight. If the number of calls in ' // &
           'that channel falls below this threshold, the weight is not ' // &
           'lowered further but kept at this threshold. (cf. also ' // &
           '\ttt{channel\_weights\_power})'))
     call var_list%append_int (var_str ("min_calls_per_channel"), 10, &
           intrinsic=.true., &
           description=var_str ('Integer parameter that modifies the settings ' // &
           "of the \vamp\ integrator's grid parameters. It sets the minimal " // &
           'number every channel must be called. If the number of calls ' // &
           'from the iterations is too small, \whizard\ will automatically ' // &
           'increase the number of calls. (cf. \ttt{iterations}, \ttt{min\_calls\_per\_bin}, ' // &
           '\ttt{min\_bins}, \ttt{max\_bins})'))
     call var_list%append_int (var_str ("min_calls_per_bin"), 10, &
           intrinsic=.true., &
           description=var_str ('Integer parameter that modifies the settings ' // &
           "of the \vamp\ integrator's grid parameters. It sets the minimal " // &
           'number every bin in an integration dimension must be called. ' // &
           'If the number of calls from the iterations is too small, \whizard\ ' // &
           'will automatically increase the number of calls. (cf. \ttt{iterations}, ' // &
           '\ttt{min\_calls\_per\_channel}, \ttt{min\_bins}, \ttt{max\_bins})'))
     call var_list%append_int (var_str ("min_bins"), 3, &
           intrinsic=.true., &
           description=var_str ('Integer parameter that modifies the settings ' // &
           "of the \vamp\ integrator's grid parameters. It sets the minimal " // &
           'number of bins per integration dimension. (cf. \ttt{iterations}, ' // &
           '\ttt{max\_bins}, \ttt{min\_calls\_per\_channel}, \ttt{min\_calls\_per\_bin})'))
     call var_list%append_int (var_str ("max_bins"), 20, &
           intrinsic=.true., &
           description=var_str ('Integer parameter that modifies the settings ' // &
           "of the \vamp\ integrator's grid parameters. It sets the maximal " // &
           'number of bins per integration dimension. (cf. \ttt{iterations}, ' // &
           '\ttt{min\_bins}, \ttt{min\_calls\_per\_channel}, \ttt{min\_calls\_per\_bin})'))
     call var_list%append_log (var_str ("?stratified"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that switches between stratified ' // &
           'and importance sampling for the \vamp\ integration method.'))
     call var_list%append_log (var_str ("?use_vamp_equivalences"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whether equivalence ' // &
           'relations (symmetries) between different integration channels ' // &
           'are used by the \vamp\ integrator.'))
     call var_list%append_log (var_str ("?vamp_verbose"), .false., &
          intrinsic=.true., &
          description=var_str ('Flag that sets the chattiness of the \vamp\ ' // &
          'integrator. If set, not only errors, but also all warnings and ' // &
          'messages will be written out (not the default). (cf. also \newline ' // &
          '\ttt{?vamp\_history\_global}, \ttt{?vamp\_history\_global\_verbose}, ' // &
          '\ttt{?vamp\_history\_channels}, \newline \ttt{?vamp\_history\_channels\_verbose})'))
     call var_list%append_log (var_str ("?vamp_history_global"), &
          .true., intrinsic=.true., &
          description=var_str ('Flag that decides whether the global history ' // &
          'of the grid adaptation of the \vamp\ integrator are written ' // &
          'into the process logfiles.  (cf. also \ttt{?vamp\_history\_global\_verbose}, ' // &
          '\ttt{?vamp\_history\_channels}, \ttt{?vamp\_history\_channels\_verbose}, ' // &
          '\ttt{?vamp\_verbose})'))
     call var_list%append_log (var_str ("?vamp_history_global_verbose"), &
          .false., intrinsic=.true., &
          description=var_str ('Flag that decides whether the global history ' // &
          'of the grid adaptation of the \vamp\ integrator are written ' // &
          'into the process logfiles in an extended version. Only for debugging ' // &
          'purposes.  (cf. also \ttt{?vamp\_history\_global}, \ttt{?vamp\_history\_channels}, ' // &
          '\ttt{?vamp\_verbose}, \ttt{?vamp\_history\_channels\_verbose})'))
     call var_list%append_log (var_str ("?vamp_history_channels"), &
          .false., intrinsic=.true., &
          description=var_str ('Flag that decides whether the history of ' // &
          'the grid adaptation of the \vamp\ integrator for every single ' // &
          'channel are written into the process logfiles. Only for debugging ' // &
          'purposes.  (cf. also \ttt{?vamp\_history\_global\_verbose}, ' // &
          '\ttt{?vamp\_history\_global}, \ttt{?vamp\_verbose}, \newline ' // &
          '\ttt{?vamp\_history\_channels\_verbose})'))
     call var_list%append_log (var_str ("?vamp_history_channels_verbose"), &
          .false., intrinsic=.true., &
          description=var_str ('Flag that decides whether the history of ' // &
          'the grid adaptation of the \vamp\ integrator for every single ' // &
          'channel are written into the process logfiles in an extended ' // &
          'version. Only for debugging purposes.  (cf. also \ttt{?vamp\_history\_global}, ' // &
          '\ttt{?vamp\_history\_channels}, \ttt{?vamp\_verbose}, \ttt{?vamp\_history\_global\_verbose})'))
     call var_list%append_string (var_str ("$run_id"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('String variable \ttt{\$run\_id = "{\em ' // &
           '<id>}"} that allows to set a special ID for a particular process ' // &
           'run, e.g. in a scan. The run ID is then attached to the process ' // &
           'log file: \newline \ttt{{\em <proc\_name>}\_{\em <proc\_comp>}.{\em ' // &
           '<id>}.log}, the \vamp\ grid file: \newline \ttt{{\em <proc\_name>}\_{\em ' // &
           '<proc\_comp>}.{\em <id>}.vg}, and the phase space file: \newline ' // &
           '\ttt{{\em <proc\_name>}\_{\em <proc\_comp>}.{\em <id>}.phs}. ' // &
           'The run ID string distinguishes among several runs for the ' // &
           'same process.  It identifies process instances with respect ' // &
           'to adapted integration grids and similar run-specific data.  ' // &
           'The run ID is kept when copying processes for creating instances, ' // &
           'however, so it does not distinguish event samples. (cf.\ also ' // &
           '\ttt{\$job\_id}, \ttt{\$compile\_workspace}'))
     call var_list%append_int (var_str ("n_calls_test"), 0, &
           intrinsic=.true., &
           description=var_str ('Integer variable that allows to set a ' // &
           'certain number of matrix element sampling test calls without ' // &
           'actually integrating the process under consideration. (cf. ' // &
           '\ttt{integrate})'))
     call var_list%append_log (var_str ("?integration_timer"), .true., &
           intrinsic=.true., &
           description=var_str ('This flag switches the integration timer ' // &
           'on and off, that gives the estimate for the duration of the ' // &
           'generation of 10,000 unweighted events for each integrated ' // &
           'process.'))
     call var_list%append_log (var_str ("?check_grid_file"), .true., &
           intrinsic=.true., &
           description=var_str ('Setting this to false turns off all sanity ' // &
           'checks when reading a grid file with previous integration data.  ' // &
           'Use this at your own risk; the program may return wrong results ' // &
           'or crash if data do not match. (cf. also \ttt{?check\_event\_file}, \ttt{?check\_phs\_file}) '))
     call var_list%append_real (var_str ("accuracy_goal"), 0._default, &
           intrinsic=.true., &
           description=var_str ('Real parameter that allows the user to ' // &
           'set a minimal accuracy that should be achieved in the Monte-Carlo ' // &
           'integration of a certain process. If that goal is reached, ' // &
           'grid and weight adapation stop, and this result is used for ' // &
           'simulation. (cf. also \ttt{integrate}, \ttt{iterations}, ' // &
           '\ttt{error\_goal}, \ttt{relative\_error\_goal}, ' // &
           '\ttt{error\_threshold})'))
     call var_list%append_real (var_str ("error_goal"), 0._default, &
           intrinsic=.true., &
           description=var_str ('Real parameter that allows the user to ' // &
           'set a minimal absolute error that should be achieved in the ' // &
           'Monte-Carlo integration of a certain process. If that goal ' // &
           'is reached, grid and weight adapation stop, and this result ' // &
           'is used for simulation. (cf. also \ttt{integrate}, \ttt{iterations}, ' // &
           '\ttt{accuracy\_goal}, \ttt{relative\_error\_goal}, \ttt{error\_threshold})'))
     call var_list%append_real (var_str ("relative_error_goal"), 0._default, &
           intrinsic=.true., &
           description=var_str ('Real parameter that allows the user to ' // &
           'set a minimal relative error that should be achieved in the ' // &
           'Monte-Carlo integration of a certain process. If that goal ' // &
           'is reached, grid and weight adaptation stop, and this result ' // &
           'is used for simulation. (cf. also \ttt{integrate}, \ttt{iterations}, ' // &
           '\ttt{accuracy\_goal}, \ttt{error\_goal}, \ttt{error\_threshold})'))
     call var_list%append_int (var_str ("integration_results_verbosity"), 1, &
           intrinsic=.true., &
           description=var_str ('Integer parameter for the verbosity of ' // &
           'the integration results in the process-specific logfile.'))
     call var_list%append_real (var_str ("error_threshold"), &
          0._default, intrinsic=.true., &
          description=var_str ('The real parameter \ttt{error\_threshold ' // &
          '= {\em <num>}} declares that any error value (in absolute numbers) ' // &
          'smaller than \ttt{{\em <num>}} is to be considered zero. The ' // &
          'units are \ttt{fb} for scatterings and \ttt{GeV} for decays. ' // &
          '(cf. also \ttt{integrate}, \ttt{iterations}, \ttt{accuracy\_goal}, ' // &
          '\ttt{error\_goal}, \ttt{relative\_error\_goal})'))
     call var_list%append_real (var_str ("channel_weights_power"), 0.25_default, &
           intrinsic=.true., &
           description=var_str ('Real parameter that allows to vary the ' // &
           'exponent of the channel weights for the \vamp\ integrator.'))
     call var_list%append_string (var_str ("$integrate_workspace"), &
           intrinsic=.true., &
           description=var_str ('Character string that tells \whizard\ ' // &
           'the subdirectory where to find the run-specific phase-space ' // &
           'configuration and the \vamp\ and \vamptwo\ grid files. ' // &
           'If undefined (as per default), \whizard\ creates them and ' // &
           'searches for them in the ' // &
           'current directory.  (cf. also  \ttt{\$job\_id}, ' // &
           '\ttt{\$run\_id}, \ttt{\$compile\_workspace})'))
   end subroutine var_list_set_integration_defaults
 
 @ %def var_list_set_integration_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_phase_space_defaults => var_list_set_phase_space_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_phase_space_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_string (var_str ("$phs_method"), var_str ("default"), &
           intrinsic=.true., &
           description=var_str ('String variable that allows to choose ' // &
           'the phase-space parameterization method. The default is the ' // &
           '\ttt{"wood"} method that takes into account electroweak/BSM ' // &
           'resonances. Note that this might not be the best choice for ' // &
           '(pure) QCD amplitudes. (cf. also \ttt{\$phs\_file})'))
     call var_list%append_log (var_str ("?vis_channels"), .false., &
           intrinsic=.true., &
           description=var_str ('Optional logical argument for the \ttt{integrate} ' // &
           'command that demands \whizard\ to generate a PDF or postscript ' // &
           'output showing the classification of the found phase space ' // &
           'channels (if the phase space method \ttt{wood} has been used) ' // &
           'according to their properties: \ttt{integrate (foo) \{ iterations=3:10000 ' // &
           '?vis\_channels = true \}}. The default is \ttt{false}.  (cf. ' // &
           'also \ttt{integrate}, \ttt{?vis\_history})'))
     call var_list%append_log (var_str ("?check_phs_file"), .true., &
           intrinsic=.true., &
           description=var_str ('Setting this to false turns off all sanity ' // &
           'checks when reading a previously generated phase-space configuration ' // &
           'file.  Use this at your own risk; the program may return wrong ' // &
           'results or crash if data do not match. (cf. also \ttt{?check\_event\_file}, ' // &
           '\ttt{?check\_grid\_file})'))
     call var_list%append_string (var_str ("$phs_file"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('This string variable allows the user to ' // &
           'set an individual file name for the phase space parameterization ' // &
           'for a particular process: \ttt{\$phs\_file = "{\em <file\_name>}"}. ' // &
           'If not set, the default is \ttt{{\em <proc\_name>}\_{\em <proc\_comp>}.{\em ' // &
           '<run\_id>}.phs}. (cf. also \ttt{\$phs\_method})'))
     call var_list%append_log (var_str ("?phs_only"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag (particularly as optional argument ' // &
           'of the $\to$ \ttt{integrate} command) that allows to only generate ' // &
           'the phase space file, but not perform the integration. (cf. ' // &
           'also \ttt{\$phs\_method}, \ttt{\$phs\_file})'))
     call var_list%append_real (var_str ("phs_threshold_s"), 50._default, &
           intrinsic=.true., &
           description=var_str ('For the phase space method \ttt{wood}, ' // &
           'this real parameter sets the threshold below which particles ' // &
           'are assumed to be massless in the $s$-channel like kinematic ' // &
           'regions. (cf. also \ttt{phs\_threshold\_t}, \ttt{phs\_off\_shell}, ' // &
           '\ttt{phs\_t\_channel}, \ttt{phs\_e\_scale}, \ttt{phs\_m\_scale}, ' // &
           '\newline \ttt{phs\_q\_scale}, \ttt{?phs\_keep\_resonant}, \ttt{?phs\_step\_mapping}, ' // &
           '\ttt{?phs\_step\_mapping\_exp}, \newline \ttt{?phs\_s\_mapping})'))
     call var_list%append_real (var_str ("phs_threshold_t"), 100._default, &
           intrinsic=.true., &
           description=var_str ('For the phase space method \ttt{wood}, ' // &
           'this real parameter sets the threshold below which particles ' // &
           'are assumed to be massless in the $t$-channel like kinematic ' // &
           'regions. (cf. also \ttt{phs\_threshold\_s}, \ttt{phs\_off\_shell}, ' // &
           '\ttt{phs\_t\_channel}, \ttt{phs\_e\_scale}, \ttt{phs\_m\_scale}, ' // &
           '\newline \ttt{phs\_q\_scale}, \ttt{?phs\_keep\_resonant}, \ttt{?phs\_step\_mapping}, ' // &
           '\ttt{?phs\_step\_mapping\_exp}, \newline \ttt{?phs\_s\_mapping})'))
     call var_list%append_int (var_str ("phs_off_shell"), 2, &
           intrinsic=.true., &
           description=var_str ('Integer parameter that sets the number ' // &
           'of off-shell (not $t$-channel-like, non-resonant) lines that ' // &
           'are taken into account to find a valid phase-space setup in ' // &
           'the \ttt{wood} phase-space method.  (cf. also \ttt{phs\_threshold\_t}, ' // &
           '\ttt{phs\_threshold\_s}, \ttt{phs\_t\_channel}, \ttt{phs\_e\_scale}, ' // &
           '\ttt{phs\_m\_scale}, \ttt{phs\_q\_scale}, \ttt{?phs\_keep\_resonant}, ' // &
           '\ttt{?phs\_step\_mapping}, \newline \ttt{?phs\_step\_mapping\_exp}, ' // &
           '\ttt{?phs\_s\_mapping})'))
     call var_list%append_int (var_str ("phs_t_channel"), 6, &
           intrinsic=.true., &
           description=var_str ('Integer parameter that sets the number ' // &
           'of $t$-channel propagators in multi-peripheral diagrams that ' // &
           'are taken into account to find a valid phase-space setup in ' // &
           'the \ttt{wood} phase-space method.  (cf. also \ttt{phs\_threshold\_t}, ' // &
           '\ttt{phs\_threshold\_s}, \ttt{phs\_off\_shell}, \ttt{phs\_e\_scale}, ' // &
           '\ttt{phs\_m\_scale}, \ttt{phs\_q\_scale}, \ttt{?phs\_keep\_resonant}, ' // &
           '\ttt{?phs\_step\_mapping}, \newline \ttt{?phs\_step\_mapping\_exp}, ' // &
           '\ttt{?phs\_s\_mapping})'))
     call var_list%append_real (var_str ("phs_e_scale"), 10._default, &
           intrinsic=.true., &
           description=var_str ('Real parameter that sets the energy scale ' // &
           'that acts as a cutoff for parameterizing radiation-like kinematics ' // &
           'in the \ttt{wood} phase space method. \whizard\ takes the maximum ' // &
           'of this value and the width of the propagating particle as ' // &
           'a cutoff. (cf. also \ttt{phs\_threshold\_t}, \ttt{phs\_threshold\_s}, ' // &
           '\ttt{phs\_t\_channel}, \ttt{phs\_off\_shell}, \ttt{phs\_m\_scale}, ' // &
           '\ttt{phs\_q\_scale}, \newline \ttt{?phs\_keep\_resonant}, \ttt{?phs\_step\_mapping}, ' // &
           '\ttt{?phs\_step\_mapping\_exp}, \ttt{?phs\_s\_mapping})'))
     call var_list%append_real (var_str ("phs_m_scale"), 10._default, &
           intrinsic=.true., &
           description=var_str ('Real parameter that sets the mass scale ' // &
           'that acts as a cutoff for parameterizing collinear and infrared ' // &
           'kinematics in the \ttt{wood} phase space method. \whizard\ ' // &
           'takes the maximum of this value and the mass of the propagating ' // &
           'particle as a cutoff. (cf. also \ttt{phs\_threshold\_t}, \ttt{phs\_threshold\_s}, ' // &
           '\ttt{phs\_t\_channel}, \ttt{phs\_off\_shell},  \ttt{phs\_e\_scale}, ' // &
           '\ttt{phs\_q\_scale}, \newline \ttt{?phs\_keep\_resonant}, \ttt{?phs\_step\_mapping}, ' // &
           '\ttt{?phs\_step\_mapping\_exp}, \ttt{?phs\_s\_mapping})'))
     call var_list%append_real (var_str ("phs_q_scale"), 10._default, &
           intrinsic=.true., &
           description=var_str ('Real parameter that sets the momentum ' // &
           'transfer scale that acts as a cutoff for parameterizing $t$- ' // &
           'and $u$-channel like kinematics in the \ttt{wood} phase space ' // &
           'method. \whizard\ takes the maximum of this value and the mass ' // &
           'of the propagating particle as a cutoff. (cf. also \ttt{phs\_threshold\_t}, ' // &
           '\ttt{phs\_threshold\_s}, \ttt{phs\_t\_channel}, \ttt{phs\_off\_shell},  ' // &
           '\ttt{phs\_e\_scale}, \ttt{phs\_m\_scale}, \ttt{?phs\_keep\_resonant}, ' // &
           '\ttt{?phs\_step\_mapping}, \ttt{?phs\_step\_mapping\_exp}, ' // &
           '\newline \ttt{?phs\_s\_mapping})'))
     call var_list%append_log (var_str ("?phs_keep_nonresonant"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whether the \ttt{wood} ' // &
           'phase space method takes into account also non-resonant contributions.  ' // &
           '(cf. also \ttt{phs\_threshold\_t}, \ttt{phs\_threshold\_s}, ' // &
           '\ttt{phs\_t\_channel}, \ttt{phs\_off\_shell}, \ttt{phs\_m\_scale}, ' // &
           '\ttt{phs\_q\_scale}, \ttt{phs\_e\_scale}, \ttt{?phs\_step\_mapping}, ' // &
           '\newline \ttt{?phs\_step\_mapping\_exp}, \ttt{?phs\_s\_mapping})'))
     call var_list%append_log (var_str ("?phs_step_mapping"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that switches on (or off) a particular ' // &
           'phase space mapping for resonances, where the mass and width ' // &
           'of the resonance are explicitly set as channel cutoffs. (cf. ' // &
           'also \ttt{phs\_threshold\_t}, \ttt{phs\_threshold\_s}, \ttt{phs\_t\_channel}, ' // &
           '\ttt{phs\_off\_shell},  \ttt{phs\_e\_scale}, \newline \ttt{phs\_m\_scale}, ' // &
           '\ttt{?phs\_keep\_resonant}, \ttt{?phs\_q\_scale}, \ttt{?phs\_step\_mapping\_exp}, ' // &
           '\newline \ttt{?phs\_s\_mapping})'))
     call var_list%append_log (var_str ("?phs_step_mapping_exp"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that switches on (or off) a particular ' // &
           'phase space mapping for resonances, where the mass and width ' // &
           'of the resonance are explicitly set as channel cutoffs. This ' // &
           'is an exponential mapping in contrast to ($\to$) \ttt{?phs\_step\_mapping}. ' // &
           '(cf. also \ttt{phs\_threshold\_t}, \ttt{phs\_threshold\_s}, ' // &
           '\ttt{phs\_t\_channel}, \ttt{phs\_off\_shell},  \ttt{phs\_e\_scale}, ' // &
           '\ttt{phs\_m\_scale}, \newline \ttt{?phs\_q\_scale}, \ttt{?phs\_keep\_resonant}, ' // &
           '\ttt{?phs\_step\_mapping}, \ttt{?phs\_s\_mapping})'))
     call var_list%append_log (var_str ("?phs_s_mapping"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that allows special mapping for $s$-channel ' // &
           'resonances.  (cf. also \ttt{phs\_threshold\_t}, \ttt{phs\_threshold\_s}, ' // &
           '\ttt{phs\_t\_channel}, \ttt{phs\_off\_shell},  \ttt{phs\_e\_scale}, ' // &
           '\ttt{phs\_m\_scale}, \newline \ttt{?phs\_keep\_resonant}, \ttt{?phs\_q\_scale}, ' // &
           '\ttt{?phs\_step\_mapping}, \ttt{?phs\_step\_mapping\_exp})'))
     call var_list%append_log (var_str ("?vis_history"), .false., &
           intrinsic=.true., &
           description=var_str ('Optional logical argument for the \ttt{integrate} ' // &
           'command that demands \whizard\ to generate a PDF or postscript ' // &
           'output showing the adaptation history of the Monte-Carlo integration ' // &
           'of the process under consideration. (cf. also \ttt{integrate}, ' // &
           '\ttt{?vis\_channels})'))
   end subroutine var_list_set_phase_space_defaults
 
 @ %def var_list_set_phase_space_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_gamelan_defaults => var_list_set_gamelan_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_gamelan_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_int (&
          var_str ("n_bins"), 20, &
          intrinsic=.true., &
          description=var_str ("Settings for \whizard's internal graphics " // &
          'output: integer value that sets the number of bins in histograms. ' // &
          '(cf. also \ttt{?normalize\_bins}, \ttt{\$obs\_label}, \ttt{\$obs\_unit}, ' // &
          '\ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, \ttt{\$y\_label}, ' // &
          '\ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, \ttt{?y\_log}, ' // &
          '\ttt{?x\_log}, \ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, ' // &
          '\ttt{\$gmlcode\_bg}, \ttt{\$gmlcode\_fg}, \ttt{?draw\_histogram}, ' // &
          '\ttt{?draw\_base}, \ttt{?draw\_piecewise}, \ttt{?fill\_curve}, ' // &
          '\ttt{?draw\_curve}, \ttt{?draw\_errors}, \ttt{?draw\_symbols}, ' // &
          '\newline \ttt{\$fill\_options}, \ttt{\$draw\_options}, \ttt{\$err\_options}, ' // &
          '\ttt{\$symbol})'))
     call var_list%append_log (&
          var_str ("?normalize_bins"), .false., &
          intrinsic=.true., &
          description=var_str ("Settings for \whizard's internal graphics " // &
          'output: flag that determines whether the weights shall be normalized ' // &
          'to the bin width or not. (cf. also \ttt{n\_bins}, \ttt{\$obs\_label}, ' // &
          '\ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, ' // &
          '\ttt{\$y\_label}, \ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, ' // &
          '\ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, ' // &
          '\ttt{y\_max}, \ttt{\$gmlcode\_bg}, \ttt{\$gmlcode\_fg}, \ttt{?draw\_histogram}, ' // &
          '\newline \ttt{?draw\_base}, \ttt{?draw\_piecewise}, \ttt{?fill\_curve}, ' // &
          '\ttt{?draw\_curve}, \ttt{?draw\_errors}, \ttt{\$symbol}, \newline ' // &
          '\ttt{?draw\_symbols}, \ttt{\$fill\_options}, \ttt{\$draw\_options}, ' // &
          '\ttt{\$err\_options})'))
     call var_list%append_string (var_str ("$obs_label"), var_str (""), &
          intrinsic=.true., &
          description=var_str ("Settings for \whizard's internal graphics " // &
          'output: this is a string variable \ttt{\$obs\_label = "{\em ' // &
          '<LaTeX\_Code>}"} that allows to attach a label to a plotted ' // &
          'or histogrammed observable. (cf. also \ttt{n\_bins}, \ttt{?normalize\_bins}, ' // &
          '\ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, ' // &
          '\ttt{\$y\_label}, \ttt{?y\_log}, \ttt{?x\_log}, \ttt{graph\_width\_mm}, ' // &
          '\ttt{graph\_height\_mm}, \ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, ' // &
          '\ttt{y\_max}, \ttt{\$gmlcode\_bg}, \ttt{\$gmlcode\_fg}, \ttt{?draw\_base}, ' // &
          '\ttt{?draw\_histogram}, \ttt{?draw\_piecewise}, \newline \ttt{?fill\_curve}, ' // &
          '\ttt{?draw\_curve}, \ttt{?draw\_errors}, \ttt{\$symbol}, \ttt{?draw\_symbols}, ' // &
          '\ttt{\$fill\_options}, \ttt{\$draw\_options}, \ttt{\$err\_options})'))
     call var_list%append_string (var_str ("$obs_unit"), var_str (""), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: this is a string variable \ttt{\$obs\_unit = "{\em ' // &
           '<LaTeX\_Code>}"} that allows to attach a \LaTeX\ physical unit ' // &
           'to a plotted or histogrammed observable. (cf. also \ttt{n\_bins}, ' // &
           '\ttt{?normalize\_bins}, \ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, ' // &
           '\ttt{\$x\_label}, \ttt{\$y\_label}, \ttt{?y\_log}, \ttt{?x\_log}, ' // &
           '\ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, \ttt{x\_min}, ' // &
           '\ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{\$gmlcode\_fg}, \ttt{?draw\_base}, \ttt{?draw\_histogram}, ' // &
           '\ttt{?fill\_curve}, \ttt{?draw\_piecewise}, \ttt{?draw\_curve}, ' // &
           '\ttt{?draw\_errors}, \ttt{\$symbol}, \ttt{?draw\_symbols}, ' // &
           '\ttt{\$fill\_options}, \ttt{\$draw\_options}, \ttt{\$err\_options})'))
     call var_list%append_string (var_str ("$title"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('This string variable sets the title of ' // &
           'a plot in a \whizard\ analysis setup, e.g. a histogram or an ' // &
           'observable. The syntax is \ttt{\$title = "{\em <your title>}"}. ' // &
           'This title appears as a section header in the analysis file, ' // &
           'but not in the screen output of the analysis.  (cf. also \ttt{n\_bins}, ' // &
           '\ttt{?normalize\_bins}, \ttt{\$obs\_unit}, \ttt{\$description}, ' // &
           '\ttt{\$x\_label}, \ttt{\$y\_label}, \ttt{?y\_log}, \ttt{?x\_log}, ' // &
           '\ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, \ttt{x\_min}, ' // &
           '\ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{\$gmlcode\_fg}, \ttt{?draw\_base}, \ttt{?draw\_histogram}, ' // &
           '\ttt{?fill\_curve}, \ttt{?draw\_piecewise}, \newline \ttt{?draw\_curve}, ' // &
           '\ttt{?draw\_errors}, \ttt{\$symbol}, \ttt{?draw\_symbols}, ' // &
           '\ttt{\$fill\_options}, \ttt{\$draw\_options}, \ttt{\$err\_options})'))
     call var_list%append_string (var_str ("$description"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('String variable that allows to specify ' // &
           'a description text for the analysis, \ttt{\$description = "{\em ' // &
           '<LaTeX analysis descr.>}"}.  This line appears below the title ' // &
           'of a corresponding analysis, on top of the respective plot.  ' // &
           '(cf. also \ttt{analysis}, \ttt{n\_bins}, \ttt{?normalize\_bins}, ' // &
           '\ttt{\$obs\_unit}, \ttt{\$x\_label}, \ttt{\$y\_label}, \ttt{?y\_log}, ' // &
           '\ttt{?x\_log}, \ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{\$gmlcode\_fg}, \ttt{?draw\_base}, \ttt{?draw\_histogram}, ' // &
           '\ttt{?fill\_curve}, \ttt{?draw\_piecewise}, \ttt{?draw\_curve}, ' // &
           '\ttt{?draw\_errors}, \ttt{\$symbol}, \ttt{?draw\_symbols}, ' // &
           '\ttt{\$fill\_options}, \ttt{\$draw\_options}, \ttt{\$err\_options})'))
     call var_list%append_string (var_str ("$x_label"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('String variable, \ttt{\$x\_label = "{\em ' // &
           '<LaTeX code>}"}, that sets the $x$ axis label in a plot or ' // &
           'histogram in a \whizard\ analysis.  (cf. also \ttt{analysis}, ' // &
           '\ttt{n\_bins}, \ttt{?normalize\_bins}, \ttt{\$obs\_unit}, \ttt{\$y\_label}, ' // &
           '\ttt{?y\_log}, \ttt{?x\_log}, \ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \newline ' // &
           '\ttt{\$gmlcode\_bg}, \ttt{\$gmlcode\_fg}, \ttt{?draw\_base}, ' // &
           '\ttt{?draw\_histogram}, \ttt{?fill\_curve}, \newline \ttt{?draw\_piecewise}, ' // &
           '\ttt{?draw\_curve}, \ttt{?draw\_errors}, \ttt{\$symbol}, \ttt{?draw\_symbols}, ' // &
           '\ttt{\$fill\_options}, \ttt{\$draw\_options}, \ttt{\$err\_options})'))
     call var_list%append_string (var_str ("$y_label"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('String variable, \ttt{\$y\_label = "{\em ' // &
           '<LaTeX\_code>}"}, that sets the $y$ axis label in a plot or ' // &
           'histogram in a \whizard\ analysis.  (cf. also \ttt{analysis}, ' // &
           '\ttt{n\_bins}, \ttt{?normalize\_bins}, \ttt{\$obs\_unit}, \ttt{?y\_log}, ' // &
           '\ttt{?x\_log}, \ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \newline ' // &
           '\ttt{\$gmlcode\_bg}, \ttt{\$gmlcode\_fg}, \ttt{?draw\_base}, ' // &
           '\ttt{?draw\_histogram}, \ttt{?fill\_curve}, \newline \ttt{?draw\_piecewise}, ' // &
           '\ttt{?draw\_curve}, \ttt{?draw\_errors}, \ttt{\$symbol}, \ttt{?draw\_symbols}, ' // &
           '\newline \ttt{\$fill\_options}, \ttt{\$draw\_options}, \ttt{\$err\_options})'))
     call var_list%append_int (var_str ("graph_width_mm"), 130, &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: integer value that sets the width of a graph or histogram ' // &
           'in millimeters. (cf. also \ttt{?normalize\_bins}, \ttt{\$obs\_label}, ' // &
           '\ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, ' // &
           '\ttt{\$y\_label}, \ttt{graph\_height\_mm}, \ttt{?y\_log}, \ttt{?x\_log}, ' // &
           '\ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{\$gmlcode\_fg}, \ttt{?draw\_histogram}, \ttt{?draw\_base}, ' // &
           '\newline \ttt{?draw\_piecewise}, \ttt{?fill\_curve}, \ttt{?draw\_curve}, ' // &
           '\ttt{?draw\_errors}, \ttt{?draw\_symbols}, \newline \ttt{\$fill\_options}, ' // &
           '\ttt{\$draw\_options}, \ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_int (var_str ("graph_height_mm"), 90, &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: integer value that sets the height of a graph or histogram ' // &
           'in millimeters. (cf. also \ttt{?normalize\_bins}, \ttt{\$obs\_label}, ' // &
           '\ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, ' // &
           '\ttt{\$y\_label}, \ttt{graph\_width\_mm}, \ttt{?y\_log}, \ttt{?x\_log}, ' // &
           '\ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{\$gmlcode\_fg}, \ttt{?draw\_histogram}, \ttt{?draw\_base}, ' // &
           '\newline \ttt{?draw\_piecewise}, \ttt{?fill\_curve}, \ttt{?draw\_curve}, ' // &
           '\ttt{?draw\_errors}, \ttt{?draw\_symbols}, \newline \ttt{\$fill\_options}, ' // &
           '\ttt{\$draw\_options}, \ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_log (var_str ("?y_log"), .false., &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: flag that makes the $y$ axis logarithmic. (cf. also ' // &
           '\ttt{?normalize\_bins}, \ttt{\$obs\_label}, \ttt{\$obs\_unit}, ' // &
           '\ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, \ttt{\$y\_label}, ' // &
           '\ttt{graph\_height\_mm}, \ttt{graph\_width\_mm}, \ttt{?y\_log}, ' // &
           '\ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \newline ' // &
           '\ttt{\$gmlcode\_bg}, \ttt{\$gmlcode\_fg}, \ttt{?draw\_histogram}, ' // &
           '\ttt{?draw\_base}, \ttt{?draw\_piecewise}, \newline \ttt{?fill\_curve}, ' // &
           '\ttt{?draw\_curve}, \ttt{?draw\_errors}, \ttt{?draw\_symbols}, ' // &
           '\ttt{\$fill\_options}, \newline \ttt{\$draw\_options}, \ttt{\$err\_options}, ' // &
           '\ttt{\$symbol})'))
     call var_list%append_log (var_str ("?x_log"), .false., &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: flag that makes the $x$ axis logarithmic. (cf. also ' // &
           '\ttt{?normalize\_bins}, \ttt{\$obs\_label}, \ttt{\$obs\_unit}, ' // &
           '\ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, \ttt{\$y\_label}, ' // &
           '\ttt{graph\_height\_mm}, \ttt{graph\_width\_mm}, \ttt{?y\_log}, ' // &
           '\ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \newline ' // &
           '\ttt{\$gmlcode\_bg}, \ttt{\$gmlcode\_fg}, \ttt{?draw\_histogram}, ' // &
           '\ttt{?draw\_base}, \ttt{?draw\_piecewise}, \newline \ttt{?fill\_curve}, ' // &
           '\ttt{?draw\_curve}, \ttt{?draw\_errors}, \ttt{?draw\_symbols}, ' // &
           '\ttt{\$fill\_options}, \newline \ttt{\$draw\_options}, \ttt{\$err\_options}, ' // &
           '\ttt{\$symbol})'))
     call var_list%append_real (var_str ("x_min"),  &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: real parameter that sets the lower limit of the $x$ ' // &
           'axis plotting or histogram interval. (cf. also \ttt{?normalize\_bins}, ' // &
           '\ttt{\$obs\_label}, \ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, ' // &
           '\ttt{\$x\_label}, \ttt{\$y\_label}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{?y\_log}, \newline \ttt{?x\_log}, \ttt{graph\_width\_mm}, ' // &
           '\ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{\$gmlcode\_fg}, \ttt{?draw\_base}, \newline \ttt{?draw\_histogram}, ' // &
           '\ttt{?draw\_piecewise}, \ttt{?fill\_curve}, \ttt{?draw\_curve}, ' // &
           '\ttt{?draw\_errors}, \newline \ttt{?draw\_symbols}, \ttt{\$fill\_options}, ' // &
           '\ttt{\$draw\_options}, \ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_real (var_str ("x_max"),  &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: real parameter that sets the upper limit of the $x$ ' // &
           'axis plotting or histogram interval. (cf. also \ttt{?normalize\_bins}, ' // &
           '\ttt{\$obs\_label}, \ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, ' // &
           '\ttt{\$x\_label}, \ttt{\$y\_label}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{?y\_log}, \newline \ttt{?x\_log}, \ttt{graph\_width\_mm}, ' // &
           '\ttt{x\_min}, \ttt{y\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{\$gmlcode\_fg}, \ttt{?draw\_base}, \newline \ttt{?draw\_histogram}, ' // &
           '\ttt{?draw\_piecewise}, \ttt{?fill\_curve}, \ttt{?draw\_curve}, ' // &
           '\ttt{?draw\_errors}, \newline \ttt{?draw\_symbols}, \ttt{\$fill\_options}, ' // &
           '\ttt{\$draw\_options}, \ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_real (var_str ("y_min"),  &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: real parameter that sets the lower limit of the $y$ ' // &
           'axis plotting or histogram interval. (cf. also \ttt{?normalize\_bins}, ' // &
           '\ttt{\$obs\_label}, \ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, ' // &
           '\ttt{\$x\_label}, \ttt{\$y\_label}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{?y\_log}, \newline \ttt{?x\_log}, \ttt{graph\_width\_mm}, ' // &
           '\ttt{x\_max}, \ttt{y\_max}, \ttt{x\_min}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{\$gmlcode\_fg}, \ttt{?draw\_base}, \newline \ttt{?draw\_histogram}, ' // &
           '\ttt{?draw\_piecewise}, \ttt{?fill\_curve}, \ttt{?draw\_curve}, ' // &
           '\ttt{?draw\_errors}, \newline \ttt{?draw\_symbols}, \ttt{\$fill\_options}, ' // &
           '\ttt{\$draw\_options}, \ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_real (var_str ("y_max"),  &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: real parameter that sets the upper limit of the $y$ ' // &
           'axis plotting or histogram interval. (cf. also \ttt{?normalize\_bins}, ' // &
           '\ttt{\$obs\_label}, \ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, ' // &
           '\ttt{\$x\_label}, \ttt{\$y\_label}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{?y\_log}, \newline \ttt{?x\_log}, \ttt{graph\_width\_mm}, ' // &
           '\ttt{x\_max}, \ttt{x\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{\$gmlcode\_fg}, \ttt{?draw\_base}, \newline \ttt{?draw\_histogram}, ' // &
           '\ttt{?draw\_piecewise}, \ttt{?fill\_curve}, \ttt{?draw\_curve}, ' // &
           '\ttt{?draw\_errors}, \newline \ttt{?draw\_symbols}, \ttt{\$fill\_options}, ' // &
           '\ttt{\$draw\_options}, \ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_string (var_str ("$gmlcode_bg"), var_str (""), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: string variable that allows to define a background ' // &
           'for plots and histograms (i.e. it is overwritten by the plot/histogram), ' // &
           'e.g. a grid: \ttt{\$gmlcode\_bg = "standardgrid.lr(5);"}. For ' // &
           'more details, see the \gamelan\ manual. (cf. also \ttt{?normalize\_bins}, ' // &
           '\ttt{\$obs\_label}, \ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, ' // &
           '\ttt{\$x\_label}, \ttt{\$y\_label}, \ttt{graph\_width\_mm}, ' // &
           '\ttt{graph\_height\_mm}, \ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, ' // &
           '\ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_fg}, ' // &
           '\ttt{?draw\_histogram}, \ttt{?draw\_base}, \ttt{?draw\_piecewise}, ' // &
           '\newline \ttt{?fill\_curve}, \ttt{?draw\_curve}, \ttt{?draw\_errors}, ' // &
           '\ttt{?draw\_symbols}, \ttt{\$fill\_options}, \newline \ttt{\$draw\_options}, ' // &
           '\ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_string (var_str ("$gmlcode_fg"), var_str (""), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: string variable that allows to define a foreground ' // &
           'for plots and histograms (i.e. it overwrites the plot/histogram), ' // &
           'e.g. a grid: \ttt{\$gmlcode\_bg = "standardgrid.lr(5);"}. For ' // &
           'more details, see the \gamelan\ manual. (cf. also \ttt{?normalize\_bins}, ' // &
           '\ttt{\$obs\_label}, \ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, ' // &
           '\ttt{\$x\_label}, \ttt{\$y\_label}, \ttt{graph\_width\_mm}, ' // &
           '\ttt{graph\_height\_mm}, \ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, ' // &
           '\ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{?draw\_histogram}, \ttt{?draw\_base}, \ttt{?draw\_piecewise}, ' // &
           '\newline \ttt{?fill\_curve}, \ttt{?draw\_curve}, \ttt{?draw\_errors}, ' // &
           '\ttt{?draw\_symbols}, \ttt{\$fill\_options}, \newline \ttt{\$draw\_options}, ' // &
           '\ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_log (var_str ("?draw_histogram"), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: flag that tells \whizard\ to either plot data as a ' // &
           'histogram or as a continuous line (if $\to$ \ttt{?draw\_curve} ' // &
           'is set \ttt{true}). (cf. also \ttt{?normalize\_bins}, \ttt{\$obs\_label}, ' // &
           '\ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, ' // &
           '\ttt{\$y\_label}, \ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, ' // &
           '\ttt{y\_max}, \newline \ttt{\$gmlcode\_fg}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{?draw\_base}, \ttt{?draw\_piecewise}, \ttt{?fill\_curve}, ' // &
           '\ttt{?draw\_curve}, \ttt{?draw\_errors}, \ttt{?draw\_symbols}, ' // &
           '\ttt{\$fill\_options}, \ttt{\$draw\_options}, \ttt{\$err\_options}, ' // &
           '\ttt{\$symbol})'))
     call var_list%append_log (var_str ("?draw_base"), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: flag that tells \whizard\ to insert a \ttt{base} statement ' // &
           'in the analysis code to calculate the plot data from a data ' // &
           'set. (cf. also \ttt{?normalize\_bins}, \ttt{\$obs\_label}, ' // &
           '\ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, ' // &
           '\ttt{\$y\_label}, \ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, ' // &
           '\ttt{y\_max}, \newline \ttt{\$gmlcode\_fg}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{?draw\_curve}, \ttt{?draw\_piecewise}, \ttt{?fill\_curve}, ' // &
           '\ttt{\$symbol}, \newline \ttt{?draw\_histogram}, \ttt{?draw\_errors}, ' // &
           '\ttt{?draw\_symbols}, \ttt{\$fill\_options}, \ttt{\$draw\_options}, ' // &
           '\newline \ttt{\$err\_options})'))
     call var_list%append_log (var_str ("?draw_piecewise"), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: flag that tells \whizard\ to data from a data set piecewise, ' // &
           'i.e. histogram style. (cf. also \ttt{?normalize\_bins}, \ttt{\$obs\_label}, ' // &
           '\ttt{\$obs\_unit},  \ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, ' // &
           '\ttt{\$y\_label}, \ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, \ttt{x\_max},  ' // &
           '\ttt{y\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_fg}, \ttt{\$gmlcode\_bg},  ' // &
           '\ttt{?draw\_curve}, \ttt{?draw\_base}, \ttt{?fill\_curve}, ' // &
           '\ttt{\$symbol}, \ttt{?draw\_histogram}, \ttt{?draw\_errors}, ' // &
           '\ttt{?draw\_symbols}, \ttt{\$fill\_options}, \ttt{\$draw\_options}, ' // &
           '\ttt{\$err\_options})'))
     call var_list%append_log (var_str ("?fill_curve"), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: flag that tells \whizard\ to fill data curves (e.g. ' // &
           'as a histogram). The style can be set with $\to$ \ttt{\$fill\_options ' // &
           '= "{\em <LaTeX\_code>}"}. (cf. also \ttt{?normalize\_bins}, ' // &
           '\ttt{\$obs\_label}, \ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, ' // &
           '\ttt{\$x\_label}, \ttt{\$y\_label}, \ttt{graph\_width\_mm}, ' // &
           '\ttt{graph\_height\_mm}, \ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, ' // &
           '\ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \newline \ttt{\$gmlcode\_fg}, ' // &
           '\ttt{\$gmlcode\_bg}, \ttt{?draw\_base}, \ttt{?draw\_piecewise}, ' // &
           '\ttt{?draw\_curve}, \ttt{?draw\_histogram}, \ttt{?draw\_errors}, ' // &
           '\ttt{?draw\_symbols}, \ttt{\$fill\_options}, \ttt{\$draw\_options}, ' // &
           '\ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_log (var_str ("?draw_curve"), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: flag that tells \whizard\ to either plot data as a ' // &
           'continuous line or as a histogram (if $\to$ \ttt{?draw\_histogram} ' // &
           'is set \ttt{true}). (cf. also \ttt{?normalize\_bins}, \ttt{\$obs\_label}, ' // &
           '\ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, ' // &
           '\ttt{\$y\_label}, \ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, ' // &
           '\ttt{y\_max}, \newline \ttt{\$gmlcode\_fg}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{?draw\_base}, \ttt{?draw\_piecewise}, \ttt{?fill\_curve}, ' // &
           '\ttt{?draw\_histogram}, \ttt{?draw\_errors}, \ttt{?draw\_symbols}, ' // &
           '\ttt{\$fill\_options}, \ttt{\$draw\_options}, \ttt{\$err\_options}, ' // &
           '\ttt{\$symbol})'))
     call var_list%append_log (var_str ("?draw_errors"), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: flag that determines whether error bars should be drawn ' // &
           'or not. (cf. also \ttt{?normalize\_bins}, \ttt{\$obs\_label}, ' // &
           '\ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, ' // &
           '\ttt{\$y\_label}, \ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, ' // &
           '\ttt{y\_max}, \ttt{\$gmlcode\_fg}, \ttt{\$gmlcode\_bg}, \ttt{?draw\_base}, ' // &
           '\ttt{?draw\_piecewise}, \ttt{?fill\_curve}, \ttt{?draw\_histogram}, ' // &
           '\ttt{?draw\_curve}, \ttt{?draw\_symbols}, \ttt{\$fill\_options}, ' // &
           '\newline \ttt{\$draw\_options}, \ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_log (var_str ("?draw_symbols"), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: flag that determines whether particular symbols (specified ' // &
           'by $\to$ \ttt{\$symbol = "{\em <LaTeX\_code>}"}) should be ' // &
           'used for plotting data points  (cf. also \ttt{?normalize\_bins}, ' // &
           '\ttt{\$obs\_label}, \ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, ' // &
           '\ttt{\$x\_label}, \ttt{\$y\_label}, \ttt{graph\_width\_mm}, ' // &
           '\ttt{graph\_height\_mm}, \ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, ' // &
           '\ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_fg}, ' // &
           '\ttt{\$gmlcode\_bg}, \ttt{?draw\_base}, \ttt{?draw\_piecewise}, ' // &
           '\ttt{?fill\_curve}, \ttt{?draw\_histogram}, \ttt{?draw\_curve}, ' // &
           '\ttt{?draw\_errors}, \ttt{\$fill\_options}, \ttt{\$draw\_options}, ' // &
           '\newline \ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_string (var_str ("$fill_options"), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: \ttt{\$fill\_options = "{\em <LaTeX\_code>}"} is a ' // &
           'string variable that allows to set fill options when plotting ' // &
           'data as filled curves with the $\to$ \ttt{?fill\_curve} flag. ' // &
           'For more details see the \gamelan\ manual. (cf. also \ttt{?normalize\_bins}, ' // &
           '\ttt{\$obs\_label}, \ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, ' // &
           '\ttt{\$x\_label}, \ttt{\$y\_label}, \ttt{graph\_width\_mm}, ' // &
           '\ttt{graph\_height\_mm}, \ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, ' // &
           '\ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}, \ttt{\$gmlcode\_fg}, ' // &
           '\ttt{\$gmlcode\_bg}, \ttt{?draw\_base}, \ttt{?draw\_piecewise}, ' // &
           '\ttt{?draw\_curve}, \ttt{?draw\_histogram}, \ttt{?draw\_errors}, ' // &
           '\newline \ttt{?draw\_symbols}, \ttt{?fill\_curve}, \ttt{\$draw\_options}, ' // &
           '\ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_string (var_str ("$draw_options"), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: \ttt{\$draw\_options = "{\em <LaTeX\_code>}"} is a ' // &
           'string variable that allows to set specific drawing options ' // &
           'for plots and histograms. For more details see the \gamelan\ ' // &
           'manual. (cf. also \ttt{?normalize\_bins}, \ttt{\$obs\_label}, ' // &
           '\ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, ' // &
           '\ttt{\$y\_label}, \ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, ' // &
           '\ttt{y\_max}, \ttt{\$gmlcode\_fg}, \ttt{\$gmlcode\_bg}, \ttt{?draw\_base}, ' // &
           '\newline \ttt{?draw\_piecewise}, \ttt{?fill\_curve}, \ttt{?draw\_histogram}, ' // &
           '\ttt{?draw\_errors}, \ttt{?draw\_symbols}, \newline \ttt{\$fill\_options}, ' // &
           '\ttt{?draw\_histogram}, \ttt{\$err\_options}, \ttt{\$symbol})'))
     call var_list%append_string (var_str ("$err_options"), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: \ttt{\$err\_options = "{\em <LaTeX\_code>}"} is a string ' // &
           'variable that allows to set specific drawing options for errors ' // &
           'in plots and histograms. For more details see the \gamelan\ ' // &
           'manual. (cf. also \ttt{?normalize\_bins}, \ttt{\$obs\_label}, ' // &
           '\ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, ' // &
           '\ttt{\$y\_label}, \ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, ' // &
           '\ttt{y\_max}, \ttt{\$gmlcode\_fg}, \ttt{\$gmlcode\_bg}, \ttt{?draw\_base}, ' // &
           '\ttt{?draw\_piecewise}, \ttt{?fill\_curve}, \ttt{?draw\_histogram}, ' // &
           '\ttt{?draw\_errors}, \newline \ttt{?draw\_symbols}, \ttt{\$fill\_options}, ' // &
           '\ttt{?draw\_histogram}, \ttt{\$draw\_options}, \ttt{\$symbol})'))
     call var_list%append_string (var_str ("$symbol"), &
           intrinsic=.true., &
           description=var_str ("Settings for \whizard's internal graphics " // &
           'output: \ttt{\$symbol = "{\em <LaTeX\_code>}"} is a string ' // &
           'variable for the symbols that should be used for plotting data ' // &
           'points.  (cf. also \ttt{\$obs\_label}, \ttt{?normalize\_bins}, ' // &
           '\ttt{\$obs\_unit}, \ttt{\$title}, \ttt{\$description}, \ttt{\$x\_label}, ' // &
           '\ttt{\$y\_label}, \newline \ttt{graph\_width\_mm}, \ttt{graph\_height\_mm}, ' // &
           '\ttt{?y\_log}, \ttt{?x\_log}, \ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, ' // &
           '\ttt{y\_max}, \newline \ttt{\$gmlcode\_fg}, \ttt{\$gmlcode\_bg}, ' // &
           '\ttt{?draw\_base}, \ttt{?draw\_piecewise}, \ttt{?fill\_curve}, ' // &
           '\newline \ttt{?draw\_histogram}, \ttt{?draw\_curve}, \ttt{?draw\_errors}, ' // &
           '\ttt{\$fill\_options}, \ttt{\$draw\_options}, \newline \ttt{\$err\_options}, ' // &
           '\ttt{?draw\_symbols})'))
     call var_list%append_log (&
          var_str ("?analysis_file_only"), .false., &
          intrinsic=.true., &
          description=var_str ('Allows to specify that only \LaTeX\ files ' // &
          "for \whizard's graphical analysis are written out, but not processed. " // &
          '(cf. \ttt{compile\_analysis}, \ttt{write\_analysis})'))
   end subroutine var_list_set_gamelan_defaults
 
 @ %def var_list_set_gamelan_defaults
 @ FastJet parameters and friends
 <<Variables: var list: TBP>>=
   procedure :: set_clustering_defaults => var_list_set_clustering_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_clustering_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_int (&
          var_str ("kt_algorithm"), &
          kt_algorithm, &
          intrinsic = .true., locked = .true., &
          description=var_str ('Specifies a jet algorithm for the ($\to$) ' // &
          '\ttt{jet\_algorithm} command, used in the ($\to$) \ttt{cluster} ' // &
          'subevent function. At the moment only available for the ' // &
          'interfaced external \fastjet\ package.  (cf. also ' // &
          '\ttt{cambridge\_[for\_passive\_]algorithm}, ' // &
          '\ttt{plugin\_algorithm}, ' // &
          '\newline\ttt{genkt\_[for\_passive\_]algorithm}, ' // &
          '\ttt{ee\_[gen]kt\_algorithm}, \ttt{jet\_r})'))
     call var_list%append_int (&
          var_str ("cambridge_algorithm"), &
          cambridge_algorithm, intrinsic = .true., locked = .true., &
          description=var_str ('Specifies a jet algorithm for the ($\to$) ' // &
          '\ttt{jet\_algorithm} command, used in the ($\to$) \ttt{cluster} ' // &
          'subevent function. At the moment only available for the interfaced ' // &
          'external \fastjet\ package.  (cf. also \ttt{kt\_algorithm}, ' // &
          '\ttt{cambridge\_for\_passive\_algorithm}, \ttt{plugin\_algorithm}, ' // &
          '\ttt{genkt\_[for\_passive\_]algorithm}, \ttt{ee\_[gen]kt\_algorithm}, ' // &
          '\ttt{jet\_r})'))
     call var_list%append_int (&
          var_str ("antikt_algorithm"), &
          antikt_algorithm, &
          intrinsic = .true., locked = .true., &
          description=var_str ('Specifies a jet algorithm for the ($\to$) ' // &
          '\ttt{jet\_algorithm} command, used in the ($\to$) \ttt{cluster} ' // &
          'subevent function. At the moment only available for the interfaced ' // &
          'external \fastjet\ package.  (cf. also \ttt{kt\_algorithm}, ' // &
          '\ttt{cambridge\_[for\_passive\_]algorithm}, \ttt{plugin\_algorithm}, ' // &
          '\ttt{genkt\_[for\_passive\_]algorithm}, \ttt{ee\_[gen]kt\_algorithm}, ' // &
          '\ttt{jet\_r})'))
     call var_list%append_int (&
          var_str ("genkt_algorithm"), &
          genkt_algorithm, &
          intrinsic = .true., locked = .true., &
          description=var_str ('Specifies a jet algorithm for the ($\to$) ' // &
          '\ttt{jet\_algorithm} command, used in the ($\to$) \ttt{cluster} ' // &
          'subevent function. At the moment only available for the interfaced ' // &
          'external \fastjet\ package.  (cf. also \ttt{kt\_algorithm}, ' // &
          '\ttt{cambridge\_for\_passive\_algorithm}, \ttt{plugin\_algorithm}, ' // &
          '\ttt{genkt\_for\_passive\_algorithm}, \ttt{ee\_[gen]kt\_algorithm}, ' // &
          '\ttt{jet\_r})'))
     call var_list%append_int (&
          var_str ("cambridge_for_passive_algorithm"), &
          cambridge_for_passive_algorithm, &
          intrinsic = .true., locked = .true., &
          description=var_str ('Specifies a jet algorithm for the ($\to$) ' // &
          '\ttt{jet\_algorithm} command, used in the ($\to$) \ttt{cluster} ' // &
          'subevent function. At the moment only available for the interfaced ' // &
          'external \fastjet\ package.  (cf. also \ttt{kt\_algorithm}, ' // &
          '\ttt{cambridge\_algorithm}, \ttt{plugin\_algorithm}, \newline ' // &
          '\ttt{genkt\_[for\_passive\_]algorithm}, \ttt{ee\_[gen]kt\_algorithm}, ' // &
          '\ttt{jet\_r})'))
     call var_list%append_int (&
          var_str ("genkt_for_passive_algorithm"), &
          genkt_for_passive_algorithm, &
          intrinsic = .true., locked = .true., &
          description=var_str ('Specifies a jet algorithm for the ($\to$) ' // &
          '\ttt{jet\_algorithm} command, used in the ($\to$) \ttt{cluster} ' // &
          'subevent function. At the moment only available for the interfaced ' // &
          'external \fastjet\ package.  (cf. also \ttt{kt\_algorithm}, ' // &
          '\ttt{cambridge\_for\_passive\_algorithm}, \ttt{plugin\_algorithm}, ' // &
          '\ttt{genkt\_algorithm}, \ttt{ee\_[gen]kt\_algorithm}, \ttt{jet\_r})'))
     call var_list%append_int (&
          var_str ("ee_kt_algorithm"), &
          ee_kt_algorithm, &
          intrinsic = .true., locked = .true., &
          description=var_str ('Specifies a jet algorithm for the ($\to$) ' // &
          '\ttt{jet\_algorithm} command, used in the ($\to$) \ttt{cluster} ' // &
          'subevent function. At the moment only available for the interfaced ' // &
          'external \fastjet\ package.  (cf. also \ttt{kt\_algorithm}, ' // &
          '\ttt{cambridge\_[for\_passive\_]algorithm}, \ttt{plugin\_algorithm}, ' // &
          '\ttt{genkt\_[for\_passive\_]algorithm}, \ttt{ee\_genkt\_algorithm}, ' // &
          '\ttt{jet\_r})'))
     call var_list%append_int (&
          var_str ("ee_genkt_algorithm"), &
          ee_genkt_algorithm, &
          intrinsic = .true., locked = .true., &
          description=var_str ('Specifies a jet algorithm for the ($\to$) ' // &
          '\ttt{jet\_algorithm} command, used in the ($\to$) \ttt{cluster} ' // &
          'subevent function. At the moment only available for the interfaced ' // &
          'external \fastjet\ package.  (cf. also \ttt{kt\_algorithm}, ' // &
          '\ttt{cambridge\_[for\_passive\_]algorithm}, \ttt{plugin\_algorithm}, ' // &
          '\ttt{genkt\_[for\_passive\_]algorithm}, \ttt{ee\_kt\_algorithm}, ' // &
          '\ttt{jet\_r})'))
     call var_list%append_int (&
          var_str ("plugin_algorithm"), &
          plugin_algorithm, &
          intrinsic = .true., locked = .true., &
          description=var_str ('Specifies a jet algorithm for the ($\to$) ' // &
          '\ttt{jet\_algorithm} command, used in the ($\to$) \ttt{cluster} ' // &
          'subevent function. At the moment only available for the interfaced ' // &
          'external \fastjet\ package.  (cf. also \ttt{kt\_algorithm}, ' // &
          '\ttt{cambridge\_for\_passive\_algorithm}, \newline ' // &
          '\ttt{genkt\_[for\_passive\_]algorithm}, \ttt{ee\_[gen]kt\_algorithm}, ' // &
          '\ttt{jet\_r})'))
     call var_list%append_int (&
          var_str ("undefined_jet_algorithm"), &
          undefined_jet_algorithm, &
          intrinsic = .true., locked = .true., &
          description=var_str ('This is just a place holder for any kind of jet ' // & 
          'jet algorithm that is not further specified.  (cf. also \ttt{kt\_algorithm}, ' // &
          '\ttt{cambridge\_for\_passive\_algorithm}, \newline ' // &
          '\ttt{genkt\_[for\_passive\_]algorithm}, \ttt{ee\_[gen]kt\_algorithm}, ' // &
          '\ttt{jet\_r}, \ttt{plugin\_algorithm})'))
     call var_list%append_int (&
          var_str ("jet_algorithm"), undefined_jet_algorithm, &
          intrinsic = .true., &
          description=var_str ('Variable that allows to set the type of ' // &
          'jet algorithm when using the external \fastjet\ library. It ' // &
          'accepts one of the following algorithms: ($\to$) \ttt{kt\_algorithm}, ' // &
          '\newline ($\to$) \ttt{cambridge\_[for\_passive\_]algorithm}, ' // &
          '($\to$) \ttt{antikt\_algorithm}, ($\to$) \ttt{plugin\_algorithm}, ' // &
          '($\to$) \ttt{genkt\_[for\_passive\_]algorithm}, ($\to$) ' // &
          '\ttt{ee\_[gen]kt\_algorithm}).  (cf. also \ttt{cluster}, ' // &
          '\ttt{jet\_p}, \ttt{jet\_r}, \ttt{jet\_ycut})'))
     call var_list%append_real (&
          var_str ("jet_r"), 0._default, &
          intrinsic = .true., &
          description=var_str ('Value for the distance measure $R$ used in ' // &
          'the (non-Cambridge) algorithms that are available via the interface ' // &
          'to the \fastjet\ package.  (cf. also \ttt{cluster}, \ttt{combine}, ' // &
          '\ttt{jet\_algorithm}, \ttt{kt\_algorithm}, ' // &
          '\ttt{cambridge\_[for\_passive\_]algorithm}, \ttt{antikt\_algorithm}, ' // &
          '\newline \ttt{plugin\_algorithm}, \ttt{genkt\_[for\_passive\_]algorithm}, ' // &
          '\ttt{ee\_[gen]kt\_algorithm}, \ttt{jet\_p}, \newline\ttt{jet\_ycut})'))
     call var_list%append_real (&
          var_str ("jet_p"), 0._default, &
          intrinsic = .true., &
          description=var_str ('Value for the exponent of the distance measure $R$ in ' // &
          'the generalized $k_T$ algorithms that are available via the interface ' // &
          'to the \fastjet\ package.  (cf. also \ttt{cluster}, \ttt{combine}, ' // &
          '\ttt{jet\_algorithm}, \ttt{kt\_algorithm}, ' // &
          '\ttt{cambridge\_[for\_passive\_]algorithm}, \ttt{antikt\_algorithm}, ' // &
          '\newline \ttt{plugin\_algorithm}, \ttt{genkt\_[for\_passive\_]algorithm}, ' // &
          '\ttt{ee\_[gen]kt\_algorithm}, \ttt{jet\_r}, \newline\ttt{jet\_ycut})'))
     call var_list%append_real (&
          var_str ("jet_ycut"), 0._default, &
          intrinsic = .true., &
          description=var_str ('Value for the $y$ separation measure used in ' // &
          'the Cambridge-Aachen algorithms that are available via the interface ' // &
          'to the \fastjet\ package.  (cf. also \ttt{cluster}, \ttt{combine}, ' // &
          '\ttt{kt\_algorithm}, \ttt{jet\_algorithm}, ' // &
          '\ttt{cambridge\_[for\_passive\_]algorithm}, \ttt{antikt\_algorithm}, ' // &
          '\newline \ttt{plugin\_algorithm}, \ttt{genkt\_[for\_passive\_]algorithm}, ' // &
          '\ttt{ee\_[gen]kt\_algorithm}, \ttt{jet\_p}, \newline\ttt{jet\_r})'))
     call var_list%append_log (&
          var_str ("?keep_flavors_when_clustering"), .false., &
          intrinsic = .true., &
          description=var_str ('The logical variable \ttt{?keep\_flavors\_when\_clustering ' // &
          '= true/false} specifies whether the flavor of a jet should be ' // &
          'kept during \ttt{cluster} when a jet consists of one quark and ' // &
          'zero or more gluons. Especially useful for cuts on b-tagged ' // &
          'jets (cf. also \ttt{cluster}).'))
   end subroutine var_list_set_clustering_defaults
 
 @ %def var_list_set_clustering_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_eio_defaults => var_list_set_eio_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_eio_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_string (var_str ("$sample"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('String variable to set the (base) name ' // &
           'of the event output format, e.g. \ttt{\$sample = "foo"} will ' // &
           'result in an intrinsic binary format event file \ttt{foo.evx}. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{simulate}, \ttt{hepevt}, ' // &
           '\ttt{ascii}, \ttt{athena}, \ttt{debug}, \ttt{long}, \ttt{short}, ' // &
           '\ttt{hepmc}, \ttt{lhef}, \ttt{lha}, \ttt{stdhep}, \ttt{stdhep\_up}, ' // &
           '\ttt{\$sample\_normalization}, \ttt{?sample\_pacify}, \ttt{sample\_max\_tries})'))
     call var_list%append_string (var_str ("$sample_normalization"), var_str ("auto"),&
           intrinsic=.true., &
           description=var_str ('String variable that allows to set the ' // &
           'normalization of generated events. There are four options: ' // &
           'option \ttt{"1"} (events normalized to one), \ttt{"1/n"} (sum ' // &
           'of all events in a sample normalized to one), \ttt{"sigma"} ' // &
           '(events normalized to the cross section of the process), and ' // &
           '\ttt{"sigma/n"} (sum of all events normalized to the cross ' // &
           'section). The default is \ttt{"auto"} where unweighted events ' // &
           'are normalized to one, and weighted ones to the cross section. ' // &
           '(cf. also \ttt{simulate}, \ttt{\$sample}, \ttt{sample\_format}, ' // &
           '\ttt{?sample\_pacify}, \ttt{sample\_max\_tries}, \ttt{sample\_split\_n\_evt}, ' // &
           '\ttt{sample\_split\_n\_kbytes})'))
     call var_list%append_log (var_str ("?sample_pacify"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag, mainly for debugging purposes: suppresses ' // &
           'numerical noise in the output of a simulation. (cf. also \ttt{simulate}, ' // &
           '\ttt{\$sample}, \ttt{sample\_format}, \ttt{\$sample\_normalization}, ' // &
           '\ttt{sample\_max\_tries}, \ttt{sample\_split\_n\_evt}, ' // &
           '\ttt{sample\_split\_n\_kbytes})'))
     call var_list%append_log (var_str ("?sample_select"), .true., &
           intrinsic=.true., &
           description=var_str ('Logical that determines whether a selection should ' // &
           'be applied to the output event format or not. If set to \ttt{false} a ' // &
           'selection is only considered for the evaluation of observables. (cf. ' // &
           '\ttt{select}, \ttt{selection}, \ttt{analysis})'))
     call var_list%append_int (var_str ("sample_max_tries"), 10000, &
          intrinsic = .true., &
          description=var_str ('Integer variable that sets the maximal ' // &
          'number of tries for generating a single event. The event might ' // &
          'be vetoed because of a very low unweighting efficiency, errors ' // &
          'in the event transforms like decays, shower, matching, hadronization ' // &
          'etc. (cf. also \ttt{simulate}, \ttt{\$sample}, \ttt{sample\_format}, ' // &
          '\ttt{?sample\_pacify}, \ttt{\$sample\_normalization}, ' // &
          '\ttt{sample\_split\_n\_evt}, \newline\ttt{sample\_split\_n\_kbytes})'))
     call var_list%append_int (var_str ("sample_split_n_evt"), 0, &
          intrinsic = .true., &
          description=var_str ('When generating events, this integer parameter ' // &
          '\ttt{sample\_split\_n\_evt = {\em <num>}} gives the number \ttt{{\em ' // &
          '<num>}} of breakpoints in the event files, i.e. it splits the ' // &
          'event files into \ttt{{\em <num>} + 1} parts. The parts are ' // &
          'denoted by \ttt{{\em <proc\_name>}.{\em <split\_index>}.{\em ' // &
          '<evt\_extension>}}. Here, \ttt{{\em <split\_index>}} is an integer ' // &
          'running from \ttt{0} to \ttt{{\em <num>}}. The start can be ' // &
          'reset by ($\to$) \ttt{sample\_split\_index}. (cf. also \ttt{simulate}, ' // &
          '\ttt{\$sample}, \ttt{sample\_format}, \ttt{sample\_max\_tries}, ' // &
          '\ttt{\$sample\_normalization}, \ttt{?sample\_pacify}, ' // &
          '\ttt{sample\_split\_n\_kbytes})'))
     call var_list%append_int (var_str ("sample_split_n_kbytes"), 0, &
          intrinsic = .true., &
          description=var_str ('When generating events, this integer parameter ' // &
          '\ttt{sample\_split\_n\_kbytes = {\em <num>}} limits the file ' // &
          'size of event files.  Whenever an event file has exceeded this ' // &
          'size, counted in kilobytes, the following events will be written ' // &
          'to a new file.  The naming conventions are the same as for ' // &
          '\ttt{sample\_split\_n\_evt}. (cf. also \ttt{simulate}, \ttt{\$sample}, ' // &
          '\ttt{sample\_format}, \ttt{sample\_max\_tries}, \ttt{\$sample\_normalization}, ' // &
          '\ttt{?sample\_pacify})'))
     call var_list%append_int (var_str ("sample_split_index"), 0, &
          intrinsic = .true., &
          description=var_str ('Integer number that gives the starting ' // &
          'index \ttt{sample\_split\_index = {\em <split\_index>}} for ' // &
          'the numbering of event samples \ttt{{\em <proc\_name>}.{\em ' // &
          '<split\_index>}.{\em <evt\_extension>}} split by the \ttt{sample\_split\_n\_evt ' // &
          '= {\em <num>}}. The index runs from \ttt{{\em <split\_index>}} ' // &
          'to \newline \ttt{{\em <split\_index>} + {\em <num>}}. (cf. also \ttt{simulate}, ' // &
          '\ttt{\$sample}, \ttt{sample\_format}, \newline\ttt{\$sample\_normalization}, ' // &
          '\ttt{sample\_max\_tries}, \ttt{?sample\_pacify})'))
     call var_list%append_string (var_str ("$rescan_input_format"), var_str ("raw"), &
           intrinsic=.true., &
           description=var_str ('String variable that allows to set the ' // &
           'event format of the event file that is to be rescanned by the ' // &
           '($\to$) \ttt{rescan} command.'))
     call var_list%append_log (var_str ("?read_raw"), .true., &
           intrinsic=.true., &
           description=var_str ('This flag demands \whizard\ to (try to) ' // &
           'read events (from the internal binary format) first before ' // &
           'generating new ones. (cf. \ttt{simulate}, \ttt{?write\_raw}, ' // &
           '\ttt{\$sample}, \ttt{sample\_format})'))
     call var_list%append_log (var_str ("?write_raw"), .true., &
           intrinsic=.true., &
           description=var_str ("Flag to write out events in \whizard's " // &
           'internal binary format. (cf. \ttt{simulate}, \ttt{?read\_raw}, ' // &
           '\ttt{sample\_format}, \ttt{\$sample})'))
     call var_list%append_string (var_str ("$extension_raw"), var_str ("evx"), &
          intrinsic=.true., &
          description=var_str ('String variable that allows via \ttt{\$extension\_raw ' // &
          '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
          "to which events in \whizard's internal format are written. If " // &
          'not set, the default file name and suffix is \ttt{{\em <process\_name>}.evx}. ' // &
          '(cf. also \ttt{sample\_format}, \ttt{\$sample})'))
     call var_list%append_string (var_str ("$extension_default"), var_str ("evt"), &
          intrinsic=.true., &
          description=var_str ('String variable that allows via \ttt{\$extension\_default ' // &
          '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
          'to which events in a the standard \whizard\ verbose ASCII format ' // &
          'are written. If not set, the default file name and suffix is ' // &
          '\ttt{{\em <process\_name>}.evt}. (cf. also \ttt{sample\_format}, ' // &
          '\ttt{\$sample})'))
     call var_list%append_string (var_str ("$debug_extension"), var_str ("debug"), &
           intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$debug\_extension ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in a long verbose format with debugging information ' // &
           'are written. If not set, the default file name and suffix is ' // &
           '\ttt{{\em <process\_name>}.debug}. (cf. also \ttt{sample\_format}, ' // &
           '\ttt{\$sample}, \ttt{?debug\_process}, \ttt{?debug\_transforms}, ' // &
           '\ttt{?debug\_decay}, \ttt{?debug\_verbose})'))
     call var_list%append_log (var_str ("?debug_process"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whether process information ' // &
           'will be displayed in the ASCII debug event format ($\to$) \ttt{debug}. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{\$sample}, \ttt{\$debug\_extension}, ' // &
           '\ttt{?debug\_decay}, \ttt{?debug\_transforms}, \ttt{?debug\_verbose})'))
     call var_list%append_log (var_str ("?debug_transforms"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whether information ' // &
           'about event transforms will be displayed in the ASCII debug ' // &
           'event format ($\to$) \ttt{debug}. (cf. also \ttt{sample\_format}, ' // &
           '\ttt{\$sample}, \ttt{?debug\_decay}, \ttt{\$debug\_extension}, ' // &
           '\ttt{?debug\_process}, \ttt{?debug\_verbose})'))
     call var_list%append_log (var_str ("?debug_decay"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whether decay information ' // &
           'will be displayed in the ASCII debug event format ($\to$) \ttt{debug}. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{\$sample}, \ttt{\$debug\_extension}, ' // &
           '\ttt{?debug\_process}, \ttt{?debug\_transforms}, \ttt{?debug\_verbose})'))
     call var_list%append_log (var_str ("?debug_verbose"), .true., &
           intrinsic=.true., &
           description=var_str ('Flag that decides whether extensive verbose ' // &
           'information will be included in the ASCII debug event format ' // &
           '($\to$) \ttt{debug}. (cf. also \ttt{sample\_format}, \ttt{\$sample}, ' // &
           '\ttt{\$debug\_extension}, \ttt{?debug\_decay}, \ttt{?debug\_transforms}, ' // &
           '\ttt{?debug\_process})'))
     call var_list%append_string (var_str ("$dump_extension"), var_str ("pset.dat"), &
           intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$dump\_extension ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           "to which events in \whizard's internal particle set format " // &
           'are written. If not set, the default file name and suffix is ' // &
           '\ttt{{\em <process\_name>}.pset.dat}. (cf. also \ttt{sample\_format}, ' // &
           '\ttt{\$sample}, \ttt{dump}, \ttt{?dump\_compressed}, ' // &
           '\ttt{?dump\_screen}, \ttt{?dump\_summary}, \ttt{?dump\_weights})'))
     call var_list%append_log (var_str ("?dump_compressed"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that, if set to \ttt{true}, issues ' // &
           'a very compressed and clear version of the \ttt{dump} ($\to$) ' // &
           'event format. (cf. also \ttt{sample\_format}, ' // &
           '\ttt{\$sample}, \ttt{dump}, \ttt{\$dump\_extension},  ' // &
           '\ttt{?dump\_screen}, \ttt{?dump\_summary}, \ttt{?dump\_weights})'))
     call var_list%append_log (var_str ("?dump_weights"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that, if set to \ttt{true}, includes ' // &
           'cross sections, weights and excess in the \ttt{dump} ($\to$) ' // &
           'event format. (cf. also \ttt{sample\_format}, ' // &
           '\ttt{\$sample}, \ttt{dump}, \ttt{?dump\_compressed}, ' // &
           '\ttt{\$dump\_extension}, \ttt{?dump\_screen}, \ttt{?dump\_summary})'))
     call var_list%append_log (var_str ("?dump_summary"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that, if set to \ttt{true}, includes ' // &
           'a summary with momentum sums for incoming and outgoing particles ' // &
           'as well as for beam remnants in the \ttt{dump} ($\to$) ' // &
           'event format. (cf. also \ttt{sample\_format}, ' // &
           '\ttt{\$sample}, \ttt{dump}, \ttt{?dump\_compressed}, ' // &
           '\ttt{\$dump\_extension}, \ttt{?dump\_screen}, \ttt{?dump\_weights})'))
     call var_list%append_log (var_str ("?dump_screen"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag that, if set to \ttt{true}, outputs ' // &
           'events for the \ttt{dump} ($\to$) event format on screen ' // &
           ' instead of to a file. (cf. also \ttt{sample\_format}, ' // &
           '\ttt{\$sample}, \ttt{dump}, \ttt{?dump\_compressed}, ' // &
           '\ttt{\$dump\_extension}, \ttt{?dump\_summary}, \ttt{?dump\_weights})'))
     call var_list%append_log (var_str ("?hepevt_ensure_order"), .false., &
           intrinsic=.true., &
           description=var_str ('Flag to ensure that the particle set confirms ' // &
           'the HEPEVT standard. This involves some copying and reordering ' // &
           'to guarantee that mothers and daughters are always next to ' // &
           'each other. Usually this is not necessary.'))
     call var_list%append_string (var_str ("$extension_hepevt"), var_str ("hepevt"), &
           intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$extension\_hepevt ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the \whizard\ version 1 style HEPEVT ASCII ' // &
           'format are written. If not set, the default file name and suffix ' // &
           'is \ttt{{\em <process\_name>}.hepevt}. (cf. also \ttt{sample\_format}, ' // &
           '\ttt{\$sample})'))
     call var_list%append_string (var_str ("$extension_ascii_short"), &
           var_str ("short.evt"), intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$extension\_ascii\_short ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the so called short variant of the \whizard\ ' // &
           'version 1 style HEPEVT ASCII format are written. If not set, ' // &
           'the default file name and suffix is \ttt{{\em <process\_name>}.short.evt}. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{\$sample})'))
     call var_list%append_string (var_str ("$extension_ascii_long"), &
           var_str ("long.evt"), intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$extension\_ascii\_long ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the so called long variant of the \whizard\ ' // &
           'version 1 style HEPEVT ASCII format are written. If not set, ' // &
           'the default file name and suffix is \ttt{{\em <process\_name>}.long.evt}. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{\$sample})'))
     call var_list%append_string (var_str ("$extension_athena"), &
           var_str ("athena.evt"), intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$extension\_athena ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the ATHENA file format are written. If not ' // &
           'set, the default file name and suffix is \ttt{{\em <process\_name>}.athena.evt}. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{\$sample})'))
     call var_list%append_string (var_str ("$extension_mokka"), &
            var_str ("mokka.evt"), intrinsic=.true., &
            description=var_str ('String variable that allows via \ttt{\$extension\_mokka ' // &
            '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
            'to which events in the MOKKA format are written. If not set, ' // &
            'the default file name and suffix is \ttt{{\em <process\_name>}.mokka.evt}. ' // &
            '(cf. also \ttt{sample\_format}, \ttt{\$sample})'))
     call var_list%append_string (var_str ("$lhef_version"), var_str ("2.0"), &
          intrinsic = .true., &
          description=var_str ('Specifier for the Les Houches Accord (LHEF) ' // &
          'event format files with XML headers to discriminate among different ' // &
          'versions of this format.  (cf. also \ttt{\$sample}, \ttt{sample\_format}, ' // &
          '\ttt{lhef}, \ttt{\$lhef\_extension}, \ttt{\$lhef\_extension}, ' // &
          '\ttt{?lhef\_write\_sqme\_prc}, \ttt{?lhef\_write\_sqme\_ref}, ' // &
          '\ttt{?lhef\_write\_sqme\_alt})'))
     call var_list%append_string (var_str ("$lhef_extension"), var_str ("lhe"), &
           intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$lhef\_extension ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the LHEF format are written. If not set, ' // &
           'the default file name and suffix is \ttt{{\em <process\_name>}.lhe}. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{\$sample}, \ttt{lhef}, ' // &
           '\ttt{\$lhef\_extension}, \ttt{\$lhef\_version}, \ttt{?lhef\_write\_sqme\_prc}, ' // &
           '\ttt{?lhef\_write\_sqme\_ref}, \ttt{?lhef\_write\_sqme\_alt})'))
     call var_list%append_log (var_str ("?lhef_write_sqme_prc"), .true., &
          intrinsic = .true., &
          description=var_str ('Flag that decides whether in the ($\to$) ' // &
          '\ttt{lhef} event format the weights of the squared matrix element ' // &
          'of the corresponding process shall be written in the LHE file. ' // &
          '(cf. also \ttt{\$sample}, \ttt{sample\_format}, \ttt{lhef}, ' // &
          '\ttt{\$lhef\_extension}, \ttt{\$lhef\_extension}, \ttt{?lhef\_write\_sqme\_ref}, ' // &
          '\newline \ttt{?lhef\_write\_sqme\_alt})'))
     call var_list%append_log (var_str ("?lhef_write_sqme_ref"), .false., &
          intrinsic = .true., &
          description=var_str ('Flag that decides whether in the ($\to$) ' // &
          '\ttt{lhef} event format reference weights of the squared matrix ' // &
          'element shall be written in the LHE file. (cf. also \ttt{\$sample}, ' // &
          '\ttt{sample\_format}, \ttt{lhef}, \ttt{\$lhef\_extension}, \ttt{\$lhef\_extension}, ' // &
          '\ttt{?lhef\_write\_sqme\_prc}, \ttt{?lhef\_write\_sqme\_alt})'))
     call var_list%append_log (var_str ("?lhef_write_sqme_alt"), .true., &
          intrinsic = .true., &
          description=var_str ('Flag that decides whether in the ($\to$) ' // &
          '\ttt{lhef} event format alternative weights of the squared matrix ' // &
          'element shall be written in the LHE file. (cf. also \ttt{\$sample}, ' // &
          '\ttt{sample\_format}, \ttt{lhef}, \ttt{\$lhef\_extension}, \ttt{\$lhef\_extension}, ' // &
          '\ttt{?lhef\_write\_sqme\_prc}, \ttt{?lhef\_write\_sqme\_ref})'))
     call var_list%append_string (var_str ("$extension_lha"), var_str ("lha"), &
           intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$extension\_lha ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the (deprecated) LHA format are written. ' // &
           'If not set, the default file name and suffix is \ttt{{\em <process\_name>}.lha}. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{\$sample})'))
     call var_list%append_string (var_str ("$extension_hepmc"), var_str ("hepmc"), &
           intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$extension\_hepmc ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the HepMC format are written. If not set, ' // &
           'the default file name and suffix is \ttt{{\em <process\_name>}.hepmc}. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{\$sample})'))
     call var_list%append_log (var_str ("?hepmc_output_cross_section"), .false., &
          intrinsic = .true., &
          description=var_str ('Flag for the HepMC event format that allows ' // &
          'to write out the cross section (and error) from the integration ' // &
          'together with each HepMC event. This can be used by programs ' // &
          'like Rivet to scale histograms according to the cross section. ' // &
          '(cf.  also \ttt{hepmc})'))
     call var_list%append_string (var_str ("$extension_lcio"), var_str ("slcio"), &
           intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$extension\_lcio ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the LCIO format are written. If not set, ' // &
           'the default file name and suffix is \ttt{{\em <process\_name>}.slcio}. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{\$sample})'))
     call var_list%append_string (var_str ("$extension_stdhep"), var_str ("hep"), &
           intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$extension\_stdhep ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the StdHEP format via the HEPEVT common ' // &
           'block are written. If not set, the default file name and suffix ' // &
           'is \ttt{{\em <process\_name>}.hep}. (cf. also \ttt{sample\_format}, ' // &
           '\ttt{\$sample})'))
     call var_list%append_string (var_str ("$extension_stdhep_up"), &
           var_str ("up.hep"), intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$extension\_stdhep\_up ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the StdHEP format via the HEPRUP/HEPEUP ' // &
           'common blocks are written. \ttt{{\em <process\_name>}.up.hep} ' // &
           'is the default file name and suffix, if this variable not set. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{\$sample})'))
     call var_list%append_string (var_str ("$extension_stdhep_ev4"), &
           var_str ("ev4.hep"), intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$extension\_stdhep\_ev4 ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the StdHEP format via the HEPEVT/HEPEV4 ' // &
           'common blocks are written. \ttt{{\em <process\_name>}.up.hep} ' // &
           'is the default file name and suffix, if this variable not set. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{\$sample})'))
     call var_list%append_string (var_str ("$extension_hepevt_verb"), &
           var_str ("hepevt.verb"), intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$extension\_hepevt\_verb ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the \whizard\ version 1 style extended or ' // &
           'verbose HEPEVT ASCII format are written. If not set, the default ' // &
           'file name and suffix is \ttt{{\em <process\_name>}.hepevt.verb}. ' // &
           '(cf. also \ttt{sample\_format}, \ttt{\$sample})'))
     call var_list%append_string (var_str ("$extension_lha_verb"), &
           var_str ("lha.verb"), intrinsic=.true., &
           description=var_str ('String variable that allows via \ttt{\$extension\_lha\_verb ' // &
           '= "{\em <suffix>}"} to specify the suffix for the file \ttt{name.suffix} ' // &
           'to which events in the (deprecated) extended or verbose LHA ' // &
           'format are written. If not set, the default file name and suffix ' // &
           'is \ttt{{\em <process\_name>}.lha.verb}. (cf. also \ttt{sample\_format}, ' // &
           '\ttt{\$sample})'))
   end subroutine var_list_set_eio_defaults
 
 @ %def var_list_set_eio_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_shower_defaults => var_list_set_shower_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_shower_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_log (var_str ("?allow_shower"), .true., &
          intrinsic=.true., &
          description=var_str ('Master flag to switch on (initial and ' // &
          'final state) parton shower, matching/merging as an event ' // &
          'transform. As a default, it is switched on. (cf. also \ttt{?ps\_ ' // &
          '....}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_log (var_str ("?ps_fsr_active"), .false., &
          intrinsic=.true., &
          description=var_str ('Flag that switches final-state QCD radiation ' // &
          '(FSR) on.  (cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, ' // &
          '\ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_log (var_str ("?ps_isr_active"), .false., &
          intrinsic=.true., &
          description=var_str ('Flag that switches initial-state QCD ' // &
          'radiation (ISR) on.  (cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ' // &
          '...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_log (var_str ("?ps_taudec_active"), .false., &
             intrinsic=.true., &
             description=var_str ('Flag to switch on $\tau$ decays, at ' // &
             'the moment only via the included external package \ttt{TAUOLA} ' // &
             'and \ttt{PHOTOS}.  (cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ' // &
             '...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_log (var_str ("?muli_active"), .false., &
             intrinsic=.true., &
             description=var_str ("Master flag that switches on \whizard's " // &
             'module for multiple interaction with interleaved QCD parton ' // &
             'showers for hadron colliders. Note that this feature is still ' // &
             'experimental. (cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ' // &
             '...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...})'))
     call var_list%append_string (var_str ("$shower_method"), var_str ("WHIZARD"), &
             intrinsic=.true., &
             description=var_str ('String variable that allows to specify ' // &
             'which parton shower is being used, the default, \ttt{"WHIZARD"}, ' // &
             'is one of the in-house showers of \whizard. Other possibilities ' // &
             'at the moment are only \ttt{"PYTHIA6"}.'))
     call var_list%append_log (var_str ("?shower_verbose"), .false., &
             intrinsic=.true., &
             description=var_str ('Flag to switch on verbose messages when ' // &
             'using shower and/or hadronization. (cf. also \ttt{?allow\_shower}, ' // &
             '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...},'))
     call var_list%append_string (var_str ("$ps_PYTHIA_PYGIVE"), var_str (""), &
           intrinsic=.true., &
           description=var_str ('String variable that allows to pass options ' // &
           'for tunes etc. to the attached \pythia\ parton shower or hadronization, ' // &
           'e.g.: \ttt{\$ps\_PYTHIA\_PYGIVE = "MSTJ(41)=1"}.  (cf. also ' // &
           '\newline \ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ' // &
           '...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (&
          var_str ("ps_mass_cutoff"), 1._default, intrinsic = .true., &
          description=var_str ('Real value that sets the QCD parton shower ' // &
          'lower cutoff scale, where hadronization sets in. (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (&
          var_str ("ps_fsr_lambda"), 0.29_default, intrinsic = .true., &
          description=var_str ('By this real parameter, the value of $\Lambda_{QCD}$ ' // &
          'used in running $\alpha_s$ for time-like showers is set (except ' // &
          'for showers in the decay of a resonance). (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (&
          var_str ("ps_isr_lambda"), 0.29_default, intrinsic = .true., &
          description=var_str ('By this real parameter, the value of $\Lambda_{QCD}$ ' // &
          'used in running $\alpha_s$ for space-like showers is set. (cf. ' // &
          'also \ttt{?allow\_shower}, \ttt{?ps\_   ...}, \ttt{\$ps\_ ...}, ' // &
          '\ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_int (&
          var_str ("ps_max_n_flavors"), 5, intrinsic = .true., &
          description=var_str ('This integer parameter sets the maxmimum ' // &
          'number of flavors that can be produced in a QCD shower $g\to ' // &
          'q\bar q$. It is also used as the maximal number of active flavors ' // &
          'for the running of $\alpha_s$ in the shower (with a minimum ' // &
          'of 3). (cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ' // &
          '...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_log (var_str ("?ps_isr_alphas_running"), .true., &
             intrinsic=.true., &
             description=var_str ('Flag that decides whether a running ' // &
             '$\alpha_s$ is taken in space-like QCD parton showers. (cf. ' // &
             'also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, ' // &
             '\ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_log (var_str ("?ps_fsr_alphas_running"), .true., &
             intrinsic=.true., &
             description=var_str ('Flag that decides whether a running ' // &
             '$\alpha_s$ is taken in time-like QCD parton showers. (cf. ' // &
             'also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, ' // &
             '\ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str ("ps_fixed_alphas"), &
          0._default, intrinsic = .true., &
          description=var_str ('This real parameter sets the value of $\alpha_s$ ' // &
          'if it is (cf. $\to$ \ttt{?ps\_isr\_alphas\_running}, \newline ' // &
          '\ttt{?ps\_fsr\_alphas\_running}) not running in initial and/or ' // &
          'final-state QCD showers.  (cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ' // &
          '...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_log (var_str ("?ps_isr_pt_ordered"), .false., &
             intrinsic=.true., &
             description=var_str ('By this flag, it can be switched between ' // &
             'the analytic QCD ISR shower (\ttt{false}, default) and the ' // &
             '$p_T$ ISR QCD shower (\ttt{true}). (cf. also \ttt{?allow\_shower}, ' // &
             '\ttt{?ps\_   ...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_log (var_str ("?ps_isr_angular_ordered"), .true., &
             intrinsic=.true., &
             description=var_str ('If switched one, this flag forces opening ' // &
             'angles of emitted partons in the QCD ISR shower to be strictly ' // &
             'ordered, i.e. increasing towards the hard interaction.  (cf. ' // &
             'also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, ' // &
             '\ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("ps_isr_primordial_kt_width"), 0._default, intrinsic = .true., &
          description=var_str ('This real parameter sets the width $\sigma ' // &
          '= \braket{k_T^2}$ for the Gaussian primordial $k_T$ distribution ' // &
          'inside the hadron, given by: $\exp[-k_T^2/\sigma^2] k_T dk_T$.  ' // &
          '(cf. also \ttt{?allow\_shower}, \ttt{?ps\_   ...}, \ttt{\$ps\_ ' // &
          '...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("ps_isr_primordial_kt_cutoff"), 5._default, intrinsic = .true., &
          description=var_str ('Real parameter that sets the upper cutoff ' // &
          'for the primordial $k_T$ distribution inside a hadron.  (cf. ' // &
          'also \ttt{?allow\_shower}, \ttt{?ps\_   ...}, \ttt{\$ps\_ ...}, ' // &
          '\ttt{?hadronization\_active}, \ttt{?mlm\_ ...})'))
     call var_list%append_real (var_str &
          ("ps_isr_z_cutoff"), 0.999_default, intrinsic = .true., &
          description=var_str ('This real parameter allows to set the upper ' // &
          'cutoff on the splitting variable $z$ in space-like QCD parton ' // &
          'showers. (cf. also \ttt{?allow\_shower}, \ttt{?ps\_   ...}, ' // &
          '\ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("ps_isr_minenergy"), 1._default, intrinsic = .true., &
          description=var_str ('By this real parameter, the minimal effective ' // &
          'energy (in the c.m. frame) of a time-like or on-shell-emitted ' // &
          'parton in a space-like QCD shower is set. For a hard subprocess ' // &
          'that is not in the rest frame, this number is roughly reduced ' // &
          'by a boost factor $1/\gamma$ to the rest frame of the hard scattering ' // &
          'process.  (cf. also \ttt{?allow\_shower}, \ttt{?ps\_   ...}, ' // &
          '\ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("ps_isr_tscalefactor"), 1._default, intrinsic = .true., &
          description=var_str ('The $Q^2$ scale of the hard scattering ' // &
          'process is multiplied by this real factor to define the maximum ' // &
          'parton virtuality allowed in time-like QCD showers. This does ' // &
          'only apply to $t$- and $u$-channels, while for $s$-channel resonances ' // &
          'the maximum virtuality is set by $m^2$.  (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_   ...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_log (var_str &
          ("?ps_isr_only_onshell_emitted_partons"), .false., intrinsic=.true., &
          description=var_str ('This flag if set true sets all emitted ' // &
          'partons off space-like showers on-shell, i.e. it would not allow ' // &
          'associated time-like showers.  (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_   ...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?hadronization\_active})'))
   end subroutine var_list_set_shower_defaults
 
 @ %def var_list_set_shower_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_hadronization_defaults => var_list_set_hadronization_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_hadronization_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_log &
          (var_str ("?allow_hadronization"), .true., intrinsic=.true., &
          description=var_str ('Master flag to switch on hadronization ' // &
          'as an event transform. As a default, it is switched on. (cf. ' // &
          'also \ttt{?ps\_ ....}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, ' // &
          '\ttt{?hadronization\_active})'))
     call var_list%append_log &
          (var_str ("?hadronization_active"), .false., intrinsic=.true., &
          description=var_str ('Master flag to switch hadronization (through ' // &
          'the attached \pythia\ package) on or off. As a default, it is ' // &
          'off. (cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ' // &
          '...}, \ttt{?mlm\_ ...})'))
     call var_list%append_string &
          (var_str ("$hadronization_method"), var_str ("PYTHIA6"), intrinsic = .true., &
          description=var_str ("Determines whether \whizard's own " // &
          "hadronization or the (internally included) \pythiasix\ should be used."))
     call var_list%append_real &
          (var_str ("hadron_enhanced_fraction"), 0.01_default, intrinsic = .true., &
          description=var_str ('Fraction of Lund strings that break with enhanced ' // &
          'width. [not yet active]'))
     call var_list%append_real &
          (var_str ("hadron_enhanced_width"), 2.0_default, intrinsic = .true., &
          description=var_str ('Enhancement factor for the width of breaking ' // &
          'Lund strings. [not yet active]'))
   end subroutine var_list_set_hadronization_defaults
 
 @ %def var_list_set_hadronization_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_tauola_defaults => var_list_set_tauola_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_tauola_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_log (&
          var_str ("?ps_tauola_photos"), .false., intrinsic=.true., &
          description=var_str ('Flag to switch on \ttt{PHOTOS} for photon ' // &
          'showering inside the \ttt{TAUOLA} package.  (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?ps\_taudec\_active})'))
     call var_list%append_log (&
          var_str ("?ps_tauola_transverse"), .false., intrinsic=.true., &
          description=var_str ('Flag to switch transverse $\tau$ polarization ' // &
          'on or off for Higgs decays into $\tau$ leptons.  (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?ps\_taudec\_active})'))
     call var_list%append_log (&
          var_str ("?ps_tauola_dec_rad_cor"), .true., intrinsic=.true., &
          description=var_str ('Flag to switch radiative corrections for ' // &
          '$\tau$ decays in \ttt{TAUOLA} on or off.  (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?ps\_taudec\_active})'))
     call var_list%append_int (&
          var_str ("ps_tauola_dec_mode1"), 0, intrinsic = .true., &
          description=var_str ('Integer code to request a specific $\tau$ ' // &
          'decay within \ttt{TAUOLA} for the decaying $\tau$, and -- ' // &
          'in correlated decays -- for the second $\tau$. For more information ' // &
          'cf. the comments in the code or the \ttt{TAUOLA} manual.  ' // &
          '(cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ' // &
          '...}, \ttt{?mlm\_ ...}, \ttt{?ps\_taudec\_active})'))
     call var_list%append_int (&
          var_str ("ps_tauola_dec_mode2"), 0, intrinsic = .true., &
          description=var_str ('Integer code to request a specific $\tau$ ' // &
          'decay within \ttt{TAUOLA} for the decaying $\tau$, and -- ' // &
          'in correlated decays -- for the second $\tau$. For more information ' // &
          'cf. the comments in the code or the \ttt{TAUOLA} manual.  ' // &
          '(cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ' // &
          '...}, \ttt{?mlm\_ ...}, \ttt{?ps\_taudec\_active})'))
     call var_list%append_real (&
          var_str ("ps_tauola_mh"), 125._default, intrinsic = .true., &
          description=var_str ('Real option to set the Higgs mass for Higgs ' // &
          'decays into $\tau$ leptons in the interface to \ttt{TAUOLA}.  ' // &
          '(cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ' // &
          '...}, \ttt{?mlm\_ ...}, \ttt{?ps\_taudec\_active})'))
     call var_list%append_real (&
          var_str ("ps_tauola_mix_angle"), 90._default, intrinsic = .true., &
          description=var_str ('Option to set the mixing angle between ' // &
          'scalar and pseudoscalar Higgs bosons for Higgs decays into $\tau$ ' // &
          'leptons in the interface to \ttt{TAUOLA}.  (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{?mlm\_ ...}, \ttt{?ps\_taudec\_active})'))
     call var_list%append_log (&
          var_str ("?ps_tauola_pol_vector"), .false., intrinsic = .true., &
          description=var_str ('Flag to decide whether for transverse $\tau$ ' // &
          'polarization, polarization information should be taken from ' // &
          '\ttt{TAUOLA} or not.  The default is just based on random numbers.  ' // &
          '(cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ' // &
          '...}, \ttt{?mlm\_ ...}, \ttt{?ps\_taudec\_active})'))
   end subroutine var_list_set_tauola_defaults
 
 @ %def var_list_set_tauola_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_mlm_matching_defaults => var_list_set_mlm_matching_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_mlm_matching_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_log (var_str ("?mlm_matching"), .false., &
             intrinsic=.true., &
             description=var_str ('Master flag to switch on MLM (LO) jet ' // &
             'matching between hard matrix elements and the QCD parton ' // &
             'shower. (cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, ' // &
             '\ttt{\$ps\_ ...}, \ttt{mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("mlm_Qcut_ME"), 0._default, intrinsic = .true., &
          description=var_str ('Real parameter that in the MLM jet matching ' // &
          'between hard matrix elements and QCD parton shower sets a possible ' // &
          'virtuality cut on jets from the hard matrix element. (cf. also ' // &
          '\ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{mlm\_ ' // &
          '...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("mlm_Qcut_PS"), 0._default, intrinsic = .true., &
          description=var_str ('Real parameter that in the MLM jet matching ' // &
          'between hard matrix elements and QCD parton shower sets a possible ' // &
          'virtuality cut on jets from the parton shower. (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("mlm_ptmin"), 0._default, intrinsic = .true., &
          description=var_str ('This real parameter sets a minimal $p_T$ ' // &
          'that enters the $y_{cut}$ jet clustering measure in the MLM ' // &
          'jet matching between hard matrix elements and QCD parton showers.  ' // &
          '(cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ' // &
          '...}, \ttt{mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("mlm_etamax"), 0._default, intrinsic = .true., &
          description=var_str ('This real parameter sets a maximal pseudorapidity ' // &
          'that enters the MLM jet matching between hard matrix elements ' // &
          'and QCD parton showers.  (cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ' // &
          '...}, \ttt{\$ps\_ ...}, \ttt{mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("mlm_Rmin"), 0._default, intrinsic = .true., &
          description=var_str ('Real parameter that sets a minimal $R$ ' // &
          'distance value that enters the $y_{cut}$ jet clustering measure ' // &
          'in the MLM jet matching between hard matrix elements and QCD ' // &
          'parton showers.  (cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ' // &
          '...}, \ttt{\$ps\_ ...}, \ttt{mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("mlm_Emin"), 0._default, intrinsic = .true., &
          description=var_str ('Real parameter that sets a minimal energy ' // &
          '$E_{min}$ value as an infrared cutoff in the MLM jet matching ' // &
          'between hard matrix elements and QCD parton showers.  (cf. also ' // &
          '\ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{mlm\_ ' // &
          '...}, \ttt{?hadronization\_active})'))
     call var_list%append_int (var_str &
          ("mlm_nmaxMEjets"), 0, intrinsic = .true., &
          description=var_str ('This integer sets the maximal number of ' // &
          'jets that are available from hard matrix elements in the MLM ' // &
          'jet matching between hard matrix elements and QCD parton shower. ' // &
          '(cf. also \ttt{?allow\_shower}, \ttt{?ps\_ ...}, \ttt{\$ps\_ ' // &
          '...}, \ttt{mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("mlm_ETclusfactor"), 0.2_default, intrinsic = .true., &
          description=var_str ('This real parameter is a factor that enters ' // &
          'the calculation of the $y_{cut}$ measure for jet clustering ' // &
          'after the parton shower in the MLM jet matching between hard ' // &
          'matrix elements and QCD parton showers.  (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("mlm_ETclusminE"), 5._default, intrinsic = .true., &
          description=var_str ('This real parameter is a minimal energy ' // &
          'that enters the calculation of the $y_{cut}$ measure for jet ' // &
          'clustering after the parton shower in the MLM jet matching between ' // &
          'hard matrix elements and QCD parton showers.  (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("mlm_etaclusfactor"), 1._default, intrinsic = .true., &
          description=var_str ('This real parameter is a factor that enters ' // &
          'the calculation of the $y_{cut}$ measure for jet clustering ' // &
          'after the parton shower in the MLM jet matching between hard ' // &
          'matrix elements and QCD parton showers.  (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("mlm_Rclusfactor"), 1._default, intrinsic = .true., &
          description=var_str ('This real parameter is a factor that enters ' // &
          'the calculation of the $y_{cut}$ measure for jet clustering ' // &
          'after the parton shower in the MLM jet matching between hard ' // &
          'matrix elements and QCD parton showers.  (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{mlm\_ ...}, \ttt{?hadronization\_active})'))
     call var_list%append_real (var_str &
          ("mlm_Eclusfactor"), 1._default, intrinsic = .true., &
          description=var_str ('This real parameter is a factor that enters ' // &
          'the calculation of the $y_{cut}$ measure for jet clustering ' // &
          'after the parton shower in the MLM jet matching between hard ' // &
          'matrix elements and QCD parton showers.  (cf. also \ttt{?allow\_shower}, ' // &
          '\ttt{?ps\_ ...}, \ttt{\$ps\_ ...}, \ttt{mlm\_ ...}, \ttt{?hadronization\_active})'))
 
   end subroutine var_list_set_mlm_matching_defaults
 
 @ %def var_list_set_mlm_matching_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_powheg_matching_defaults => &
        var_list_set_powheg_matching_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_powheg_matching_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_log (var_str ("?powheg_matching"), &
          .false., intrinsic = .true., &
          description=var_str ('Activates Powheg matching. Needs to be ' // &
          'combined with the \ttt{?combined\_nlo\_integration}-method.'))
     call var_list%append_log (var_str ("?powheg_use_singular_jacobian"), &
          .false., intrinsic = .true., &
          description=var_str ('This allows to give a different ' // &
          'normalization of the Jacobian, resulting in an alternative ' // &
          'POWHEG damping in the singular regions.'))
     call var_list%append_int (var_str ("powheg_grid_size_xi"), &
          5, intrinsic = .true., &
          description=var_str ('Number of $\xi$ points in the POWHEG grid.'))
     call var_list%append_int (var_str ("powheg_grid_size_y"), &
          5, intrinsic = .true., &
          description=var_str ('Number of $y$ points in the POWHEG grid.'))
     call var_list%append_int (var_str ("powheg_grid_sampling_points"), &
          500000, intrinsic = .true., &
          description=var_str ('Number of calls used to initialize the ' // &
          'POWHEG grid.'))
     call var_list%append_real (var_str ("powheg_pt_min"), &
           1._default, intrinsic = .true., &
           description=var_str ('Lower $p_T$-cut-off for the POWHEG ' // &
           'hardest emission.'))
     call var_list%append_real (var_str ("powheg_lambda"), &
           LAMBDA_QCD_REF, intrinsic = .true., &
           description=var_str ('Reference scale of the $\alpha_s$ evolution ' // &
           'in the POWHEG matching algorithm.'))
     call var_list%append_log (var_str ("?powheg_rebuild_grids"), &
           .false., intrinsic = .true., &
           description=var_str ('If set to \ttt{true}, the existing POWHEG ' // &
           'grid is discarded and a new one is generated.'))
     call var_list%append_log (var_str ("?powheg_test_sudakov"), &
           .false., intrinsic = .true., &
           description=var_str ('Performs an internal consistency check ' // &
           'on the POWHEG event generation.'))
     call var_list%append_log (var_str ("?powheg_disable_sudakov"), &
           .false., intrinsic = .true., &
           description=var_str ('This flag allows to set the Sudakov form ' // &
           'factor to one. This effectively results in a version of ' // &
           'the matrix-element method (MEM) at NLO.'))
   end subroutine var_list_set_powheg_matching_defaults
 
 @ %def var_list_set_powheg_matching_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_openmp_defaults => var_list_set_openmp_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_openmp_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_log (var_str ("?omega_openmp"), &
          openmp_is_active (), &
          intrinsic=.true., &
          description=var_str ('Flag to switch on or off OpenMP multi-threading ' // &
          "for \oMega\ matrix elements. (cf. also \ttt{\$method}, \ttt{\$omega\_flag})"))
     call var_list%append_log (var_str ("?openmp_is_active"), &
          openmp_is_active (), &
          locked=.true., intrinsic=.true., &
          description=var_str ('Flag to switch on or off OpenMP multi-threading ' // &
          'for \whizard. (cf. also \ttt{?openmp\_logging}, \ttt{openmp\_num\_threads}, ' // &
          '\ttt{openmp\_num\_threads\_default}, \ttt{?omega\_openmp})'))
     call var_list%append_int (var_str ("openmp_num_threads_default"), &
          openmp_get_default_max_threads (), &
          locked=.true., intrinsic=.true., &
          description=var_str ('Integer parameter that shows the number ' // &
          'of default OpenMP threads for multi-threading. Note that this ' // &
          'parameter can only be accessed, but not reset by the user. (cf. ' // &
          'also \ttt{?openmp\_logging}, \ttt{openmp\_num\_threads}, \ttt{?omega\_openmp})'))
     call var_list%append_int (var_str ("openmp_num_threads"), &
          openmp_get_max_threads (), &
          intrinsic=.true., &
          description=var_str ('Integer parameter that sets the number ' // &
          'of OpenMP threads for multi-threading.  (cf. also \ttt{?openmp\_logging}, ' // &
          '\ttt{openmp\_num\_threads\_default}, \ttt{?omega\_openmp})'))
     call var_list%append_log (var_str ("?openmp_logging"), &
          .true., intrinsic=.true., &
          description=var_str ('This logical -- when set to \ttt{false} ' // &
          '-- suppresses writing out messages about OpenMP parallelization ' // &
          '(number of used threads etc.) on screen and into the logfile ' // &
          '(default name \ttt{whizard.log}) for the whole \whizard\ run. ' // &
          'Mainly for debugging purposes.  (cf. also \ttt{?logging}, ' // &
          '\ttt{?mpi\_logging})'))
   end subroutine var_list_set_openmp_defaults
 
 @ %def var_list_set_openmp_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_mpi_defaults => var_list_set_mpi_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_mpi_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_log (var_str ("?mpi_logging"), &
          .false., intrinsic=.true., &
          description=var_str('This logical -- when set to \ttt{false} ' // &
          '-- suppresses writing out messages about MPI parallelization ' // &
          '(number of used workers etc.) on screen and into the logfile ' // &
          '(default name \ttt{whizard.log}) for the whole \whizard\ run. ' // &
          'Mainly for debugging purposes.  (cf. also \ttt{?logging}, ' // &
          '\ttt{?openmp\_logging})'))
   end subroutine var_list_set_mpi_defaults
 
 @ %def var_list_set_mpi_defaults
 @
 <<Variables: var list: TBP>>=
   procedure :: set_nlo_defaults => var_list_set_nlo_defaults
 <<Variables: procedures>>=
   subroutine var_list_set_nlo_defaults (var_list)
     class(var_list_t), intent(inout) :: var_list
     call var_list%append_string (var_str ("$born_me_method"), &
          var_str (""), intrinsic = .true., &
          description=var_str ("This string variable specifies the method " // &
          "for the matrix elements to be used in the evaluation of the " // &
          "Born part of the NLO computation. The default is the empty string, " // &
          "i.e. the \ttt{\$method} being the intrinsic \oMega\ matrix element " // &
          'generator (\ttt{"omega"}), other options ' // &
          'are: \ttt{"ovm"}, \ttt{"unit\_test"}, \ttt{"template"}, ' // &
          '\ttt{"template\_unity"}, \ttt{"threshold"}, \ttt{"gosam"}, ' // &
          '\ttt{"openloops"}. Note that this option is inoperative if ' // &
          'no NLO calculation is specified in the process definition. ' // &
          'If you want ot use different matrix element methods in a LO ' // &
          'computation, use the usual \ttt{method} command. (cf. also ' // &
          '\ttt{\$correlation\_me\_method}, ' // &
          '\ttt{\$dglap\_me\_method}, \ttt{\$loop\_me\_method} and ' // &
          '\ttt{\$real\_tree\_me\_method}.)'))
     call var_list%append_string (var_str ("$loop_me_method"), &
          var_str (""), intrinsic = .true., &
          description=var_str ('This string variable specifies the method ' // &
          'for the matrix elements to be used in the evaluation of the ' // &
          'virtual part of the NLO computation. The default is the empty string,' // &
          'i.e. the same as \ttt{\$method}. Working options are: ' // &
          '\ttt{"threshold"}, \ttt{"openloops"}, \ttt{"recola"}, \ttt{gosam}. ' // &
          '(cf. also \ttt{\$real\_tree\_me\_method}, \ttt{\$correlation\_me\_method} ' // &
          'and \ttt{\$born\_me\_method}.)'))
     call var_list%append_string (var_str ("$correlation_me_method"), &
          var_str (""), intrinsic = .true., &
          description=var_str ('This string variable specifies ' // &
          'the method for the matrix elements to be used in the evaluation ' // &
          'of the color (and helicity) correlated part of the NLO computation. ' // &
          "The default is the same as the \ttt{\$method}, i.e. the intrinsic " // & 
          "\oMega\ matrix element generator " // &
          '(\ttt{"omega"}), other options are: \ttt{"ovm"}, \ttt{"unit\_test"}, ' // &
          '\ttt{"template"}, \ttt{"template\_unity"}, \ttt{"threshold"}, ' // &
          '\ttt{"gosam"}, \ttt{"openloops"}. (cf. also ' // &
          '\ttt{\$born\_me\_method}, \ttt{\$dglap\_me\_method}, ' // &
          '\ttt{\$loop\_me\_method} and \newline' // &
          '\ttt{\$real\_tree\_me\_method}.)'))
     call var_list%append_string (var_str ("$real_tree_me_method"), &
          var_str (""), intrinsic = .true., &
          description=var_str ('This string variable specifies the method ' // &
          'for the matrix elements to be used in the evaluation of the ' // &
          'real part of the NLO computation. The default is the same as ' // &
          'the \ttt{\$method}, i.e. the intrinsic ' // &
          "\oMega\ matrix element generator " // &
          '(\ttt{"omega"}), other options ' // &
          'are: \ttt{"ovm"}, \ttt{"unit\_test"}, \ttt{"template"}, \ttt{"template\_unity"}, ' // &
          '\ttt{"threshold"}, \ttt{"gosam"}, \ttt{"openloops"}. (cf. also ' // &
          '\ttt{\$born\_me\_method}, \ttt{\$correlation\_me\_method}, ' // &
          '\ttt{\$dglap\_me\_method} and \ttt{\$loop\_me\_method}.)'))
     call var_list%append_string (var_str ("$dglap_me_method"), &
          var_str (""), intrinsic = .true., &
          description=var_str ('This string variable specifies the method ' // &
          'for the matrix elements to be used in the evaluation of the ' // &
          'DGLAP remnants of the NLO computation. The default is the same as ' // &
          "\ttt{\$method}, i.e. the \oMega\ matrix element generator " // &
          '(\ttt{"omega"}), other options ' // &
          'are: \ttt{"ovm"}, \ttt{"unit\_test"}, \ttt{"template"}, \ttt{"template\_unity"}, ' // &
          '\ttt{"threshold"}, \ttt{"gosam"}, \ttt{"openloops"}. (cf. also \newline' // &
          '\ttt{\$born\_me\_method}, \ttt{\$correlation\_me\_method}, ' // &
          '\ttt{\$loop\_me\_method} and \ttt{\$real\_tree\_me\_method}.)'))
     call var_list%append_log (&
          var_str ("?test_soft_limit"), .false., intrinsic = .true., &
          description=var_str ('Sets the fixed values $\tilde{\xi} = 0.0001$ ' // &
          'and $y = 0.5$ as radiation variables.  This way, only soft, ' // &
          'but non-collinear phase space points are generated, which allows ' // &
          'for testing subtraction in this region.'))
     call var_list%append_log (&
          var_str ("?test_coll_limit"), .false., intrinsic = .true., &
          description=var_str ('Sets the fixed values $\tilde{\xi} = 0.5$ ' // &
          'and $y = 0.999$ as radiation variables.  This way, only collinear, ' // &
          'but non-soft phase space points are generated, which allows ' // &
          'for testing subtraction in this region. Can be combined with ' // &
          '\ttt{?test\_soft\_limit} to probe soft-collinear regions.'))
     call var_list%append_log (&
          var_str ("?test_anti_coll_limit"), .false., intrinsic = .true., &
          description=var_str ('Sets the fixed values $\tilde{\xi} = 0.5$ ' // &
          'and $y = -0.999$ as radiation variables.  This way, only anti-collinear, ' // &
          'but non-soft phase space points are generated, which allows ' // &
          'for testing subtraction in this region. Can be combined with ' // &
          '\ttt{?test\_soft\_limit} to probe soft-collinear regions.'))
     call var_list%append_string (var_str ("$select_alpha_regions"), &
          var_str (""), intrinsic = .true., &
          description=var_str ('Fixes the $\alpha_r$ in the real ' // &
          ' subtraction component. Allows for testing in one individual ' // &
          'singular region.'))
     call var_list%append_string (var_str ("$virtual_selection"), &
          var_str ("Full"), intrinsic = .true., &
          description=var_str ('String variable to select either the full ' // &
          'or only parts of the virtual components of an NLO calculation. ' // &
          'Possible modes are \ttt{"Full"}, \ttt{"OLP"} and ' // &
          '\ttt{"Subtraction."}. Mainly for debugging purposes.'))
     call var_list%append_log (var_str ("?virtual_collinear_resonance_aware"), &
          .true., intrinsic = .true., &
          description=var_str ('This flag allows to switch between two ' // &
          'different implementations of the collinear subtraction in the ' // &
          'resonance-aware FKS setup.'))
     call var_list%append_real (&
          var_str ("blha_top_yukawa"), -1._default, intrinsic = .true., &
          description=var_str ('If this value is set, the given value will ' // &
          'be used as the top Yukawa coupling instead of the top mass. ' // &
          'Note that having different values for $y_t$ and $m_t$ must be ' // &
          'supported by your OLP-library and yield errors if this is not the case.'))
     call var_list%append_string (var_str ("$blha_ew_scheme"), &
          var_str ("alpha_qed"), intrinsic = .true., &
          description=var_str ('String variable that transfers the electroweak ' // &
          'renormalization scheme via BLHA to the one-loop provider. Possible ' // &
          'values are \ttt{GF} or \ttt{Gmu} for the $G_\mu$ scheme, ' // &
          '\ttt{alpha\_qed}, \ttt{alpha\_mz} and \ttt{alpha\_0} or ' // &
          '\ttt{alpha\_thompson} for different schemes with $\alpha$ as input.'))
     call var_list%append_int (var_str ("openloops_verbosity"), 1, &
          intrinsic = .true., &
          description=var_str ('Decides how much \openloops output is printed. ' // &
          'Can have values 0, 1 and 2, where 2 is the highest verbosity level.'))
     call var_list%append_log (var_str ("?openloops_use_cms"), &
          .true., intrinsic = .true., &
          description=var_str ('Activates the complex mass scheme in ' // &
          '\openloops. (cf. also ' // &
          '\ttt{openloos\_verbosity}, \ttt{\$method}, ' // &
          '\ttt{?openloops\_switch\_off\_muon\_yukawa}, ' // &
          '\ttt{openloops\_stability\_log}, \newline' // &
          '\ttt{\$openloops\_extra\_cmd})'))
     call var_list%append_int (var_str ("openloops_phs_tolerance"), 7, &
          intrinsic = .true., &
          description=var_str ('This integer parameter gives via ' // &
          '\ttt{openloops\_phs\_tolerance = <n>} the relative numerical ' // &
          'tolerance $10^{-n}$ for the momentum conservation of the ' // &
          'external particles within \openloops. (cf. also ' // &
          '\ttt{openloos\_verbosity}, \ttt{\$method}, ' // &
          '\ttt{?openloops\_switch\_off\_muon\_yukawa}, ' // &
          '\newline\ttt{openloops\_stability\_log}, ' // &
          '\ttt{\$openloops\_extra\_cmd})'))
     call var_list%append_int (var_str ("openloops_stability_log"), 0, &
          intrinsic = .true., &
          description=var_str ('Creates the directory \ttt{stability\_log} ' // &
          'containing information about the performance of the \openloops ' // &
          'matrix elements. Possible values are 0 (No output), 1 (On ' // &
          '\ttt{finish()}-call), 2 (Adaptive) and 3 (Always).'))
     call var_list%append_log (var_str ("?openloops_switch_off_muon_yukawa"), &
          .false., intrinsic = .true., &
          description=var_str ('Sets the Yukawa coupling of muons for ' // &
          '\openloops\ to zero. (cf. also ' // &
          '\ttt{openloos\_verbosity}, \ttt{\$method}, ' // &
          '\ttt{?openloops\_use\_cms}, \ttt{openloops\_stability\_log}, ' // &
          '\ttt{\$openloops\_extra\_cmd})'))
     call var_list%append_string (var_str ("$openloops_extra_cmd"), &
           var_str (""), intrinsic = .true., &
           description=var_str ('String variable to transfer customized ' // &
           'special commands to \openloops. The three supported examples ' // &
           '\ttt{\$openloops\_extra\_command = "extra approx top/stop/not"} ' // &
           'are for selection of subdiagrams in top production. (cf. also ' // &
           '\ttt{\$method}, \ttt{openloos\_verbosity}, ' // &
           '\ttt{?openloops\_use\_cms}, \ttt{openloops\_stability\_log}, ' // &
           '\ttt{?openloops\_switch\_off\_muon\_yukawa})'))
     call var_list%append_log (var_str ("?openloops_use_collier"), &
          .true., intrinsic = .true., &
          description=var_str ('Use \collier\ as the reduction method of ' // &
          '\openloops. Otherwise, \ttt{CutTools} will be used. (cf. also ' // &
           '\ttt{\$method}, \ttt{openloos\_verbosity}, ' // &
           '\ttt{?openloops\_use\_cms}, \ttt{openloops\_stability\_log}, ' // &
           '\ttt{?openloops\_switch\_off\_muon\_yukawa})'))
     call var_list%append_log (var_str ("?disable_subtraction"), &
          .false., intrinsic = .true., &
          description=var_str ('Disables the subtraction of soft and collinear ' // &
          'divergences from the real matrix element.'))
     call var_list%append_real (var_str ("fks_dij_exp1"), &
          1._default, intrinsic = .true., &
          description=var_str ('Fine-tuning parameters of the FKS ' // &
          'partition functions. The exact meaning depends on the mapping ' // &
          'implementation. (cf. also \ttt{fks\_dij\_exp2}, ' // &
          '\ttt{\$fks\_mapping\_type}, \ttt{fks\_xi\_min}, \ttt{fks\_y\_max})'))
     call var_list%append_real (var_str ("fks_dij_exp2"), &
          1._default, intrinsic = .true., &
          description=var_str ('Fine-tuning parameters of the FKS ' // &
          'partition functions. The exact meaning depends on the mapping ' // &
          'implementation. (cf. also \ttt{fks\_dij\_exp1}, ' // &
          '\ttt{\$fks\_mapping\_type}, \ttt{fks\_xi\_min}, \ttt{fks\_y\_max})'))
     call var_list%append_real (var_str ("fks_xi_min"), &
          0.0000001_default, intrinsic = .true., &
          description=var_str ('Real parameter for the FKS ' // &
          'phase space that sets the numerical lower value of the $\xi$ ' // &
          'variable. (cf. also \ttt{fks\_dij\_exp1}, ' // &
          '\ttt{fks\_dij\_exp2}, \ttt{\$fks\_mapping\_type}, \ttt{fks\_y\_max})'))
     call var_list%append_real (var_str ("fks_y_max"), &
          1._default, intrinsic = .true., &
          description=var_str ('Real parameter for the FKS ' // &
          'phase space that sets the numerical upper value of the $y$ ' // &
          'variable. (cf. also \ttt{fks\_dij\_exp1}, ' // &
          '\ttt{\$fks\_mapping\_type}, \ttt{fks\_dij\_exp2}, \ttt{fks\_y\_max})'))
     call var_list%append_log (var_str ("?vis_fks_regions"), &
          .false., intrinsic = .true., &
          description=var_str ('Logical variable that, if set to ' // &
          '\ttt{true}, generates \LaTeX\ code and executes it into a PDF ' // &
          ' to produce a table of all singular FKS regions and their ' // &
          ' flavor structures. The default is \ttt{false}.'))
    call var_list%append_real (var_str ("fks_xi_cut"), &
         1.0_default, intrinsic = .true., &
         description = var_str ('Real paramter for the FKS ' // &
         'phase space that applies a cut to $\xi$ variable with $0 < \xi_{\text{cut}}' // &
         '\leq \xi_{\text{max}}$. The dependence on the parameter vanishs between ' // &
         'real subtraction and integrated subtraction term.'))
    call var_list%append_real (var_str ("fks_delta_zero"), &
         2._default, intrinsic = .true., &
         description = var_str ('Real paramter for the FKS ' // &
         'phase space that applies a cut to the $y$ variable with $0 < \delta_0 \leq 2$. ' // &
         'The dependence on the parameter vanishs between real subtraction and integrated' // &
         'subtraction term.'))
    call var_list%append_real (var_str ("fks_delta_i"), &
         2._default, intrinsic = .true., &
         description = var_str ('Real paramter for the FKS ' // &
         'phase space that applies a cut to the $y$ variable with $0 < \delta_{\mathrm{I}} \leq 2$ '// &
         'for initial state singularities only. ' // &
         'The dependence on the parameter vanishs between real subtraction and integrated' // &
         'subtraction term.'))
    call var_list%append_string (var_str ("$fks_mapping_type"), &
          var_str ("default"), intrinsic = .true., &
          description=var_str ('Sets the FKS mapping type. Possible values ' // &
          'are \ttt{"default"} and \ttt{"resonances"}. The latter option ' // &
          'activates the resonance-aware subtraction mode and induces the ' // &
          'generation of a soft mismatch component. (cf. also ' // &
          '\ttt{fks\_dij\_exp1}, \ttt{fks\_dij\_exp2}, \ttt{fks\_xi\_min}, ' // &
          '\ttt{fks\_y\_max})'))
     call var_list%append_string (var_str ("$resonances_exclude_particles"), &
          var_str ("default"), intrinsic = .true., &
          description=var_str ('Accepts a string of particle names. These ' // &
          'particles will be ignored when the resonance histories are generated. ' // &
          'If \ttt{\$fks\_mapping\_type} is not \ttt{"resonances"}, this ' // &
          'option does nothing.'))
     call var_list%append_int (var_str ("alpha_power"), &
          2, intrinsic = .true., &
          description=var_str ('Fixes the electroweak coupling ' // &
          'powers used by BLHA matrix element generators. Setting these ' // &
          'values is necessary for the correct generation of OLP-files. ' // &
          'Having inconsistent values yields to error messages by the corresponding ' // &
          'OLP-providers.'))
     call var_list%append_int (var_str ("alphas_power"), &
          0, intrinsic = .true., &
          description=var_str ('Fixes the strong coupling ' // &
          'powers used by BLHA matrix element generators. Setting these ' // &
          'values is necessary for the correct generation of OLP-files. ' // &
          'Having inconsistent values yields to error messages by the corresponding ' // &
          'OLP-providers.'))
     call var_list%append_log (var_str ("?combined_nlo_integration"), &
          .false., intrinsic = .true., &
          description=var_str ('When this option is set to \ttt{true}, ' // &
          'the NLO integration will not be performed in the separate components, ' // &
          'but instead the sum of all components will be integrated directly. ' // &
          'When fixed-order NLO events are requested, this integration ' // &
          'mode is possible, but not necessary.  However, it is necessary ' // &
          'for POWHEG events.'))
     call var_list%append_log (var_str ("?fixed_order_nlo_events"), &
          .false., intrinsic = .true., &
          description=var_str ('Induces the generation of fixed-order ' // &
          'NLO events.  Deprecated name: \ttt{?nlo\_fixed\_order}.'))
     call var_list%append_log (var_str ("?check_event_weights_against_xsection"), &
          .false., intrinsic = .true., &
          description=var_str ('Activates an internal recording of event ' // &
          'weights when unweighted events are generated.  At the end of ' // &
          'the simulation, the mean value of the weights and its standard ' // &
          'deviation are displayed. This allows to cross-check event generation ' // &
          'and integration, because the value displayed must be equal to ' // &
          'the integration result.'))
     call var_list%append_log (var_str ("?keep_failed_events"), &
          .false., intrinsic = .true., &
          description=var_str ('In the context of weighted event generation, ' // &
          'if set to \ttt{true}, events with failed kinematics will be ' // &
          'written to the event output with an associated weight of zero. ' // &
          'This way, the total cross section can be reconstructed from the event output.'))
     call var_list%append_int (var_str ("gks_multiplicity"), &
          0, intrinsic = .true., &
          description=var_str ('Jet multiplicity for the GKS merging scheme.'))
     call var_list%append_string (var_str ("$gosam_filter_lo"), &
          var_str (""), intrinsic = .true., &
          description=var_str ('The filter string given to \gosam\ in order to ' // &
          'filter out tree-level diagrams. (cf. also \ttt{\$gosam\_filter\_nlo}, ' // &
          '\ttt{\$gosam\_symmetries})'))
     call var_list%append_string (var_str ("$gosam_filter_nlo"), &
          var_str (""), intrinsic = .true., &
          description=var_str ('The same as \ttt{\$gosam\_filter\_lo}, but for ' // &
          'loop matrix elements. (cf. also \ttt{\$gosam\_filter\_nlo}, ' // &
          '\ttt{\$gosam\_symmetries})'))
     call var_list%append_string (var_str ("$gosam_symmetries"), &
          var_str ("family,generation"), intrinsic = .true., &
          description=var_str ('String variable that is transferred to \gosam\ ' // &
          'configuration file to determine whether certain helicity configurations ' // &
          'are considered to be equal. Possible values are \ttt{flavour}, ' // &
          '\ttt{family} etc. For more info see the \gosam\ manual.'))
     call var_list%append_int (var_str ("form_threads"), &
          2, intrinsic = .true., &
          description=var_str ('The number of threads used by \gosam when ' // &
          'matrix elements are evaluated using \ttt{FORM}'))
     call var_list%append_int (var_str ("form_workspace"), &
          1000, intrinsic = .true., &
          description=var_str ('The size of the workspace \gosam requires ' // &
          'from \ttt{FORM}. Inside \ttt{FORM}, it corresponds to the heap ' // &
          'size used by the algebra processor.'))
     call var_list%append_string (var_str ("$gosam_fc"), &
          var_str (""), intrinsic = .true., &
          description=var_str ('The Fortran compiler used by \gosam.'))
     call var_list%append_real (&
          var_str ("mult_call_real"), 1._default, &
          intrinsic = .true., &
          description=var_str ('(Real-valued) multiplier for the number ' // &
          'of calls used in the integration of the real subtraction ' // &
          'NLO component. This way, a higher accuracy can be achieved for ' // &
          'the real component, while simultaneously avoiding redundant ' // &
          'integration calls for the other components. (cf. also ' // &
          '\ttt{mult\_call\_dglap}, \ttt{mult\_call\_virt})'))
     call var_list%append_real (&
          var_str ("mult_call_virt"), 1._default, &
          intrinsic = .true., &
          description=var_str ('(Real-valued) multiplier for the number ' // &
          'of calls used in the integration of the virtual NLO ' // &
          'component. This way, a higher accuracy can be achieved for ' // &
          'this component, while simultaneously avoiding redundant ' // &
          'integration calls for the other components. (cf. also ' // &
          '\ttt{mult\_call\_dglap}, \ttt{mult\_call\_real})'))
     call var_list%append_real (&
          var_str ("mult_call_dglap"), 1._default, &
          intrinsic = .true., &
          description=var_str ('(Real-valued) multiplier for the number ' // &
          'of calls used in the integration of the DGLAP remnant NLO ' // &
          'component. This way, a higher accuracy can be achieved for ' // &
          'this component, while simultaneously avoiding redundant ' // &
          'integration calls for the other components. (cf. also ' // &
          '\ttt{mult\_call\_real}, \ttt{mult\_call\_virt})'))
     call var_list%append_string (var_str ("$dalitz_plot"), &
          var_str (''), intrinsic = .true., &
          description=var_str ('This string variable has two purposes: ' // &
          'when different from the empty string, it switches on generation ' // &
          'of the Dalitz plot file (ASCII tables) for the real emitters. ' // &
          'The string variable itself provides the file name.'))
     call var_list%append_string (var_str ("$nlo_correction_type"), &
          var_str ("QCD"), intrinsic = .true., &
          description=var_str ('String variable which sets the NLO correction ' // &
          'type via \ttt{nlo\_correction\_type = "{\em <type>}"} to either ' // &
          '\ttt{"QCD"} or \ttt{"QED"}, or to both with \ttt{\em{<type>}} ' // &
          'set to \ttt{"Full"}.'))
     call var_list%append_string (var_str ("$exclude_gauge_splittings"), &
          var_str ("c:b:t:e2:e3"), intrinsic = .true., &
          description=var_str ('String variable that allows via ' // &
          '\ttt{\$exclude\_gauge\_splittings = "{\em <prt1>:<prt2>:\dots}"} ' // &
          'to exclude fermion flavors from gluon/photon splitting into ' // &
          'fermion pairs beyond LO. For example \ttt{\$exclude\_gauge\_splittings ' // &
          '= "c:s:b:t"} would lead to \ttt{gl => u U} and \ttt{gl => d ' // &
          'D} as possible splittings in QCD. It is important to keep in ' // &
          'mind that only the particles listed in the string are excluded! ' // &
          'In QED this string would additionally allow for all splittings into ' // &
          'lepton pairs \ttt{A => l L}. Therefore, once set the variable ' // &
          'acts as a replacement of the default value, not as an addition!  ' // &
          'Note: \ttt{"\em <prt>"} can be both particle or antiparticle. It ' // &
          'will always exclude the corresponding fermion pair. An empty ' // &
          'string allows for all fermion flavors to take part in the splitting! ' // &
          'Also, particles included in an \ttt{alias} are not excluded by ' // &
          '\ttt{\$exclude\_gauge\_splittings}!'))
     call var_list%append_log (var_str ("?nlo_use_born_scale"), &
          .true., intrinsic = .true., &
          description=var_str ('Flag that decides whether a scale expression ' // &
          'defined for the Born component of an NLO process shall be applied ' // &
          'to all other components as well or not. ' // &
          '(cf. also \ttt{?nlo\_cut\_all\_sqmes})'))
     call var_list%append_log (var_str ("?nlo_cut_all_sqmes"), &
          .true., intrinsic = .true., &
          description=var_str ('Flag that decides whether in the case that ' // &
          'some NLO component does not pass a cut, all other components ' // &
          'shall be discarded for that phase space point as well or not. ' // &
          '(cf. also \ttt{?nlo\_use\_born\_scale})'))
     call var_list%append_log (var_str ("?nlo_use_real_partition"), &
           .false., intrinsic = .true., &
           description=var_str (' If set to \ttt{true}, the real matrix ' // &
           'element is split into a finite and a singular part using a ' // &
           'partition function $f$, such that $\mathcal{R} ' // &
           '= [1-f(p_T^2)]\mathcal{R} + f(p_T^2)\mathcal{R} = ' // &
           '\mathcal{R}_{\text{fin}} ' // &
           '+ \mathcal{R}_{\text{sing}}$. The emission ' // &
           'generation is then performed using $\mathcal{R}_{\text{sing}}$, ' // &
           'whereas $\mathcal{R}_{\text{fin}}$ is treated separately. ' // &
           '(cf. also \ttt{real\_partition\_scale})'))
     call var_list%append_real (var_str ("real_partition_scale"), &
           10._default, intrinsic = .true., &
           description=var_str ('This real variable sets the invariant mass ' // &
           'of the FKS pair used as a separator between the singular and the ' // &
           'finite part of the real subtraction terms in an NLO calculation, ' // &
           'e.g. in $e^+e^- \to ' // &
           't\bar tj$. (cf. also \ttt{?nlo\_use\_real\_partition})'))
   end subroutine var_list_set_nlo_defaults
 
 @ %def var_list_set_nlo_defaults
 @
 \clearpage
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Observables}
 
 In this module we define concrete variables and operators (observables)
 that we want to support in expressions.
 <<[[observables.f90]]>>=
 <<File header>>
 
 module observables
 
 <<Use kinds>>
 <<Use strings>>
   use io_units
   use diagnostics
   use lorentz
   use subevents
   use variables
 
 <<Standard module head>>
 
 <<Observables: public>>
 
 contains
 
 <<Observables: procedures>>
 
 end module observables
 @ %def observables
 @
 \subsection{Process-specific variables}
 We allow the user to set a numeric process ID for each declared process.
 <<Observables: public>>=
   public :: var_list_init_num_id
 <<Observables: procedures>>=
   subroutine var_list_init_num_id (var_list, proc_id, num_id)
     type(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: proc_id
     integer, intent(in), optional :: num_id
     call var_list_set_procvar_int (var_list, proc_id, &
          var_str ("num_id"), num_id)
   end subroutine var_list_init_num_id
 
 @ %def var_list_init_num_id
 @
 Integration results are stored in special variables.  They are
 initialized by this subroutine.  The values may or may not already
 known.
 
 Note: the values which are accessible are those that are unique for a
 process with multiple MCI records. The rest has been discarded.
 <<Observables: public>>=
   public :: var_list_init_process_results
 <<Observables: procedures>>=
   subroutine var_list_init_process_results (var_list, proc_id, &
        n_calls, integral, error, accuracy, chi2, efficiency)
     type(var_list_t), intent(inout) :: var_list
     type(string_t), intent(in) :: proc_id
     integer, intent(in), optional :: n_calls
     real(default), intent(in), optional :: integral, error, accuracy
     real(default), intent(in), optional :: chi2, efficiency
     call var_list_set_procvar_real (var_list, proc_id, &
          var_str ("integral"), integral)
     call var_list_set_procvar_real (var_list, proc_id, &
          var_str ("error"), error)
   end subroutine var_list_init_process_results
 
 @ %def var_list_init_process_results
 @
 \subsection{Observables as Pseudo-Variables}
 Unary and binary observables are different.  Most unary observables
 can be equally well evaluated for particle pairs.  Binary observables
 cannot be evaluated for single particles.
 <<Observables: public>>=
   public :: var_list_set_observables_unary
   public :: var_list_set_observables_binary
 <<Observables: procedures>>=
   subroutine var_list_set_observables_unary (var_list, prt1)
     type(var_list_t), intent(inout) :: var_list
     type(prt_t), intent(in), target :: prt1
     call var_list_append_obs1_iptr &
          (var_list, var_str ("PDG"), obs_pdg1, prt1)
     call var_list_append_obs1_iptr &
          (var_list, var_str ("Hel"), obs_helicity1, prt1)
+    call var_list_append_obs1_iptr &
+         (var_list, var_str ("Ncol"), obs_n_col1, prt1)
+    call var_list_append_obs1_iptr &
+         (var_list, var_str ("Nacl"), obs_n_acl1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("M"), obs_signed_mass1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("M2"), obs_mass_squared1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("E"), obs_energy1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("Px"), obs_px1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("Py"), obs_py1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("Pz"), obs_pz1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("P"), obs_p1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("Pl"), obs_pl1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("Pt"), obs_pt1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("Theta"), obs_theta1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("Phi"), obs_phi1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("Rap"), obs_rap1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("Eta"), obs_eta1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("Theta_star"), obs_theta_star1, prt1)
     call var_list_append_obs1_rptr &
          (var_list, var_str ("Dist"), obs_dist1, prt1)
     call var_list_append_uobs_real &
          (var_list, var_str ("_User_obs_real"), prt1)
     call var_list_append_uobs_int &
          (var_list, var_str ("_User_obs_int"), prt1)
   end subroutine var_list_set_observables_unary
 
   subroutine var_list_set_observables_binary (var_list, prt1, prt2)
     type(var_list_t), intent(inout) :: var_list
     type(prt_t), intent(in), target :: prt1
     type(prt_t), intent(in), optional, target :: prt2
     call var_list_append_obs2_iptr &
          (var_list, var_str ("PDG"), obs_pdg2, prt1, prt2)
     call var_list_append_obs2_iptr &
          (var_list, var_str ("Hel"), obs_helicity2, prt1, prt2)
+    call var_list_append_obs2_iptr &
+         (var_list, var_str ("Ncol"), obs_n_col2, prt1, prt2)
+    call var_list_append_obs2_iptr &
+         (var_list, var_str ("Nacl"), obs_n_acl2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("M"), obs_signed_mass2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("M2"), obs_mass_squared2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("E"), obs_energy2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("Px"), obs_px2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("Py"), obs_py2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("Pz"), obs_pz2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("P"), obs_p2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("Pl"), obs_pl2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("Pt"), obs_pt2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("Theta"), obs_theta2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("Phi"), obs_phi2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("Rap"), obs_rap2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("Eta"), obs_eta2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("Theta_star"), obs_theta_star2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("Dist"), obs_dist2, prt1, prt2)
     call var_list_append_obs2_rptr &
          (var_list, var_str ("kT"), obs_ktmeasure, prt1, prt2)
     call var_list_append_uobs_real &
          (var_list, var_str ("_User_obs_real"), prt1, prt2)
     call var_list_append_uobs_int &
          (var_list, var_str ("_User_obs_int"), prt1, prt2)
   end subroutine var_list_set_observables_binary
 
 @ %def var_list_set_observables_unary var_list_set_observables_binary
 @
 \subsection{Checks}
 <<Observables: public>>=
   public :: var_list_check_observable
 <<Observables: procedures>>=
   subroutine var_list_check_observable (var_list, name, type)
     class(var_list_t), intent(in), target :: var_list
     type(string_t), intent(in) :: name
     integer, intent(inout) :: type
     if (string_is_observable_id (name)) then
        call msg_fatal ("Variable name '" // char (name) &
             // "' is reserved for an observable")
        type = V_NONE
        return
     end if
   end subroutine var_list_check_observable
 
 @ %def var_list_check_observable
 @
 Check if a variable name is defined as an observable:
 <<Observables: procedures>>=
   function string_is_observable_id (string) result (flag)
     logical :: flag
     type(string_t), intent(in) :: string
     select case (char (string))
-    case ("PDG", "Hel", "M", "M2", "E", "Px", "Py", "Pz", "P", "Pl", "Pt", &
+    case ("PDG", "Hel", "Ncol", &
+         "M", "M2", "E", "Px", "Py", "Pz", "P", "Pl", "Pt", &
          "Theta", "Phi", "Rap", "Eta", "Theta_star", "Dist", "kT")
        flag = .true.
     case default
        flag = .false.
     end select
   end function string_is_observable_id
 
 @ %def string_is_observable_id
 @ Check for result and process variables.
 <<Observables: public>>=
   public :: var_list_check_result_var
 <<Observables: procedures>>=
   subroutine var_list_check_result_var (var_list, name, type)
     class(var_list_t), intent(in), target :: var_list
     type(string_t), intent(in) :: name
     integer, intent(inout) :: type
     if (string_is_integer_result_var (name))  type = V_INT
     if (.not. var_list%contains (name)) then
        if (string_is_result_var (name)) then
           call msg_fatal ("Result variable '" // char (name) // "' " &
                // "set without prior integration")
           type = V_NONE
           return
        else if (string_is_num_id (name)) then
           call msg_fatal ("Numeric process ID '" // char (name) // "' " &
                // "set without process declaration")
           type = V_NONE
           return
        end if
     end if
   end subroutine var_list_check_result_var
 
 @ %def var_list_check_result_var
 @
 Check if a variable name is a result variable of integer type:
 <<Observables: procedures>>=
   function string_is_integer_result_var (string) result (flag)
     logical :: flag
     type(string_t), intent(in) :: string
     type(string_t) :: buffer, name, separator
     buffer = string
     call split (buffer, name, "(", separator=separator)  ! ")"
     if (separator == "(") then
        select case (char (name))
        case ("num_id", "n_calls")
           flag = .true.
        case default
           flag = .false.
        end select
     else
        flag = .false.
     end if
   end function string_is_integer_result_var
 
 @ %def string_is_integer_result_var
 @
 Check if a variable name is an integration-result variable:
 <<Observables: procedures>>=
   function string_is_result_var (string) result (flag)
     logical :: flag
     type(string_t), intent(in) :: string
     type(string_t) :: buffer, name, separator
     buffer = string
     call split (buffer, name, "(", separator=separator)  ! ")"
     if (separator == "(") then
        select case (char (name))
        case ("integral", "error")
           flag = .true.
        case default
           flag = .false.
        end select
     else
        flag = .false.
     end if
   end function string_is_result_var
 
 @ %def string_is_result_var
 @
 Check if a variable name is a numeric process ID:
 <<Observables: procedures>>=
   function string_is_num_id (string) result (flag)
     logical :: flag
     type(string_t), intent(in) :: string
     type(string_t) :: buffer, name, separator
     buffer = string
     call split (buffer, name, "(", separator=separator)  ! ")"
     if (separator == "(") then
        select case (char (name))
        case ("num_id")
           flag = .true.
        case default
           flag = .false.
        end select
     else
        flag = .false.
     end if
   end function string_is_num_id
 
 @ %def string_is_num_id
 @
 \subsection{Observables}
 These are analogous to the unary and binary numeric functions listed
 above.  An observable takes the [[pval]] component(s) of its one or
 two argument nodes and produces an integer or real value.
 
 \subsubsection{Integer-valued unary observables}
 The PDG code
 <<Observables: procedures>>=
   integer function obs_pdg1 (prt1) result (pdg)
     type(prt_t), intent(in) :: prt1
     pdg = prt_get_pdg (prt1)
   end function obs_pdg1
 
 @ %def obs_pdg
 @ The helicity.  The return value is meaningful only if the particle
 is polarized, otherwise an invalid value is returned (-9).
 <<Observables: procedures>>=
   integer function obs_helicity1 (prt1) result (h)
     type(prt_t), intent(in) :: prt1
     if (prt_is_polarized (prt1)) then
        h = prt_get_helicity (prt1)
     else
        h = -9
     end if
   end function obs_helicity1
 
 @ %def obs_helicity1
+@ The number of open color (anticolor) lines.  The return value is meaningful
+only if the particle is colorized (i.e., the subevent has been given color
+information), otherwise the function returns zero.
+<<Observables: procedures>>=
+  integer function obs_n_col1 (prt1) result (n)
+    type(prt_t), intent(in) :: prt1
+    if (prt_is_colorized (prt1)) then
+       n = prt_get_n_col (prt1)
+    else
+       n = 0
+    end if
+  end function obs_n_col1
+
+  integer function obs_n_acl1 (prt1) result (n)
+    type(prt_t), intent(in) :: prt1
+    if (prt_is_colorized (prt1)) then
+       n = prt_get_n_acl (prt1)
+    else
+       n = 0
+    end if
+  end function obs_n_acl1
+
+@ %def obs_n_col1
+@ %def obs_n_acl1
 @
 \subsubsection{Real-valued unary observables}
 The invariant mass squared, obtained from the separately stored value.
 <<Observables: procedures>>=
   real(default) function obs_mass_squared1 (prt1) result (p2)
     type(prt_t), intent(in) :: prt1
     p2 = prt_get_msq (prt1)
   end function obs_mass_squared1
 
 @ %def obs_mass_squared1
 @ The signed invariant mass, which is the signed square root of the
 previous observable.
 <<Observables: procedures>>=
   real(default) function obs_signed_mass1 (prt1) result (m)
     type(prt_t), intent(in) :: prt1
     real(default) :: msq
     msq = prt_get_msq (prt1)
     m = sign (sqrt (abs (msq)), msq)
   end function obs_signed_mass1
 
 @ %def obs_signed_mass1
 @ The particle energy
 <<Observables: procedures>>=
   real(default) function obs_energy1 (prt1) result (e)
     type(prt_t), intent(in) :: prt1
     e = energy (prt_get_momentum (prt1))
   end function obs_energy1
 
 @ %def obs_energy1
 @ Particle momentum (components)
 <<Observables: procedures>>=
   real(default) function obs_px1 (prt1) result (p)
     type(prt_t), intent(in) :: prt1
     p = vector4_get_component (prt_get_momentum (prt1), 1)
   end function obs_px1
 
   real(default) function obs_py1 (prt1) result (p)
     type(prt_t), intent(in) :: prt1
     p = vector4_get_component (prt_get_momentum (prt1), 2)
   end function obs_py1
 
   real(default) function obs_pz1 (prt1) result (p)
     type(prt_t), intent(in) :: prt1
     p = vector4_get_component (prt_get_momentum (prt1), 3)
   end function obs_pz1
 
   real(default) function obs_p1 (prt1) result (p)
     type(prt_t), intent(in) :: prt1
     p = space_part_norm (prt_get_momentum (prt1))
   end function obs_p1
 
   real(default) function obs_pl1 (prt1) result (p)
     type(prt_t), intent(in) :: prt1
     p = longitudinal_part (prt_get_momentum (prt1))
   end function obs_pl1
 
   real(default) function obs_pt1 (prt1) result (p)
     type(prt_t), intent(in) :: prt1
     p = transverse_part (prt_get_momentum (prt1))
   end function obs_pt1
 
 @ %def obs_px1 obs_py1 obs_pz1
 @ %def obs_p1 obs_pl1 obs_pt1
 @ Polar and azimuthal angle (lab frame).
 <<Observables: procedures>>=
   real(default) function obs_theta1 (prt1) result (p)
     type(prt_t), intent(in) :: prt1
     p = polar_angle (prt_get_momentum (prt1))
   end function obs_theta1
 
   real(default) function obs_phi1 (prt1) result (p)
     type(prt_t), intent(in) :: prt1
     p = azimuthal_angle (prt_get_momentum (prt1))
   end function obs_phi1
 
 @ %def obs_theta1 obs_phi1
 @ Rapidity and pseudorapidity
 <<Observables: procedures>>=
   real(default) function obs_rap1 (prt1) result (p)
     type(prt_t), intent(in) :: prt1
     p = rapidity (prt_get_momentum (prt1))
   end function obs_rap1
 
   real(default) function obs_eta1 (prt1) result (p)
     type(prt_t), intent(in) :: prt1
     p = pseudorapidity (prt_get_momentum (prt1))
   end function obs_eta1
 
 @ %def obs_rap1 obs_eta1
 @ Meaningless: Polar angle in the rest frame of the two arguments
 combined.
 <<Observables: procedures>>=
   real(default) function obs_theta_star1 (prt1) result (dist)
     type(prt_t), intent(in) :: prt1
     call msg_fatal (" 'Theta_star' is undefined as unary observable")
     dist = 0
   end function obs_theta_star1
 
 @ %def obs_theta_star1
 @ [Obsolete] Meaningless: Polar angle in the rest frame of the 2nd argument.
 <<XXX Observables: procedures>>=
   real(default) function obs_theta_rf1 (prt1) result (dist)
     type(prt_t), intent(in) :: prt1
     call msg_fatal (" 'Theta_RF' is undefined as unary observable")
     dist = 0
   end function obs_theta_rf1
 
 @ %def obs_theta_rf1
 @ Meaningless: Distance on the $\eta$-$\phi$ cylinder.
 <<Observables: procedures>>=
   real(default) function obs_dist1 (prt1) result (dist)
     type(prt_t), intent(in) :: prt1
     call msg_fatal (" 'Dist' is undefined as unary observable")
     dist = 0
   end function obs_dist1
 
 @ %def obs_dist1
 @
 \subsubsection{Integer-valued binary observables}
 These observables are meaningless as binary functions.
 <<Observables: procedures>>=
   integer function obs_pdg2 (prt1, prt2) result (pdg)
     type(prt_t), intent(in) :: prt1, prt2
     call msg_fatal (" PDG_Code is undefined as binary observable")
     pdg = 0
   end function obs_pdg2
 
   integer function obs_helicity2 (prt1, prt2) result (h)
     type(prt_t), intent(in) :: prt1, prt2
     call msg_fatal (" Helicity is undefined as binary observable")
     h = 0
   end function obs_helicity2
 
+  integer function obs_n_col2 (prt1, prt2) result (n)
+    type(prt_t), intent(in) :: prt1, prt2
+    call msg_fatal (" Ncol is undefined as binary observable")
+    n = 0
+  end function obs_n_col2
+
+  integer function obs_n_acl2 (prt1, prt2) result (n)
+    type(prt_t), intent(in) :: prt1, prt2
+    call msg_fatal (" Nacl is undefined as binary observable")
+    n = 0
+  end function obs_n_acl2
+
 @ %def obs_pdg2
 @ %def obs_helicity2
+@ %def obs_n_col2
+@ %def obs_n_acl2
 @
 \subsubsection{Real-valued binary observables}
 The invariant mass squared, obtained from the separately stored value.
 <<Observables: procedures>>=
   real(default) function obs_mass_squared2 (prt1, prt2) result (p2)
     type(prt_t), intent(in) :: prt1, prt2
     type(prt_t) :: prt
     call prt_init_combine (prt, prt1, prt2)
     p2 = prt_get_msq (prt)
   end function obs_mass_squared2
 
 @ %def obs_mass_squared2
 @ The signed invariant mass, which is the signed square root of the
 previous observable.
 <<Observables: procedures>>=
   real(default) function obs_signed_mass2 (prt1, prt2) result (m)
     type(prt_t), intent(in) :: prt1, prt2
     type(prt_t) :: prt
     real(default) :: msq
     call prt_init_combine (prt, prt1, prt2)
     msq = prt_get_msq (prt)
     m = sign (sqrt (abs (msq)), msq)
   end function obs_signed_mass2
 
 @ %def obs_signed_mass2
 @ The particle energy
 <<Observables: procedures>>=
   real(default) function obs_energy2 (prt1, prt2) result (e)
     type(prt_t), intent(in) :: prt1, prt2
     type(prt_t) :: prt
     call prt_init_combine (prt, prt1, prt2)
     e = energy (prt_get_momentum (prt))
   end function obs_energy2
 
 @ %def obs_energy2
 @ Particle momentum (components)
 <<Observables: procedures>>=
   real(default) function obs_px2 (prt1, prt2) result (p)
     type(prt_t), intent(in) :: prt1, prt2
     type(prt_t) :: prt
     call prt_init_combine (prt, prt1, prt2)
     p = vector4_get_component (prt_get_momentum (prt), 1)
   end function obs_px2
 
   real(default) function obs_py2 (prt1, prt2) result (p)
     type(prt_t), intent(in) :: prt1, prt2
     type(prt_t) :: prt
     call prt_init_combine (prt, prt1, prt2)
     p = vector4_get_component (prt_get_momentum (prt), 2)
   end function obs_py2
 
   real(default) function obs_pz2 (prt1, prt2) result (p)
     type(prt_t), intent(in) :: prt1, prt2
     type(prt_t) :: prt
     call prt_init_combine (prt, prt1, prt2)
     p = vector4_get_component (prt_get_momentum (prt), 3)
   end function obs_pz2
 
   real(default) function obs_p2 (prt1, prt2) result (p)
     type(prt_t), intent(in) :: prt1, prt2
     type(prt_t) :: prt
     call prt_init_combine (prt, prt1, prt2)
     p = space_part_norm (prt_get_momentum (prt))
   end function obs_p2
 
   real(default) function obs_pl2 (prt1, prt2) result (p)
     type(prt_t), intent(in) :: prt1, prt2
     type(prt_t) :: prt
     call prt_init_combine (prt, prt1, prt2)
     p = longitudinal_part (prt_get_momentum (prt))
   end function obs_pl2
 
   real(default) function obs_pt2 (prt1, prt2) result (p)
     type(prt_t), intent(in) :: prt1, prt2
     type(prt_t) :: prt
     call prt_init_combine (prt, prt1, prt2)
     p = transverse_part (prt_get_momentum (prt))
   end function obs_pt2
 
 @ %def obs_px2 obs_py2 obs_pz2
 @ %def obs_p2 obs_pl2 obs_pt2
 @ Enclosed angle and azimuthal distance (lab frame).
 <<Observables: procedures>>=
   real(default) function obs_theta2 (prt1, prt2) result (p)
     type(prt_t), intent(in) :: prt1, prt2
     p = enclosed_angle (prt_get_momentum (prt1), prt_get_momentum (prt2))
   end function obs_theta2
 
   real(default) function obs_phi2 (prt1, prt2) result (p)
     type(prt_t), intent(in) :: prt1, prt2
     type(prt_t) :: prt
     call prt_init_combine (prt, prt1, prt2)
     p = azimuthal_distance (prt_get_momentum (prt1), prt_get_momentum (prt2))
   end function obs_phi2
 
 @ %def obs_theta2 obs_phi2
 @ Rapidity and pseudorapidity distance
 <<Observables: procedures>>=
   real(default) function obs_rap2 (prt1, prt2) result (p)
     type(prt_t), intent(in) :: prt1, prt2
     p = rapidity_distance &
          (prt_get_momentum (prt1), prt_get_momentum (prt2))
   end function obs_rap2
 
   real(default) function obs_eta2 (prt1, prt2) result (p)
     type(prt_t), intent(in) :: prt1, prt2
     type(prt_t) :: prt
     call prt_init_combine (prt, prt1, prt2)
     p = pseudorapidity_distance &
          (prt_get_momentum (prt1), prt_get_momentum (prt2))
   end function obs_eta2
 
 @ %def obs_rap2 obs_eta2
 @ [This doesn't work!  The principle of no common particle for momentum
   combination prohibits us from combining a decay particle with the momentum
   of its parent.] Polar angle in the rest frame of the 2nd argument.
 <<XXX Observables: procedures>>=
   real(default) function obs_theta_rf2 (prt1, prt2) result (theta)
     type(prt_t), intent(in) :: prt1, prt2
     theta = enclosed_angle_rest_frame &
          (prt_get_momentum (prt1), prt_get_momentum (prt2))
   end function obs_theta_rf2
 
 @ %def obs_theta_rf2
 @ Polar angle of the first particle in the rest frame of the two particles
 combined.
 <<Observables: procedures>>=
   real(default) function obs_theta_star2 (prt1, prt2) result (theta)
     type(prt_t), intent(in) :: prt1, prt2
     theta = enclosed_angle_rest_frame &
          (prt_get_momentum (prt1), &
          prt_get_momentum (prt1) + prt_get_momentum (prt2))
   end function obs_theta_star2
 
 @ %def obs_theta_star2
 @ Distance on the $\eta$-$\phi$ cylinder.
 <<Observables: procedures>>=
   real(default) function obs_dist2 (prt1, prt2) result (dist)
     type(prt_t), intent(in) :: prt1, prt2
     dist = eta_phi_distance &
          (prt_get_momentum (prt1), prt_get_momentum (prt2))
   end function obs_dist2
 
 @ %def obs_dist2
 @ Durham kT measure.
 <<Observables: procedures>>=
   real(default) function obs_ktmeasure (prt1, prt2) result (kt)
     type(prt_t), intent(in) :: prt1, prt2
     real (default) :: q2, e1, e2
     ! Normalized scale to one for now! (#67)
     q2 = 1
     e1 = energy (prt_get_momentum (prt1))
     e2 = energy (prt_get_momentum (prt2))
     kt = (2/q2) * min(e1**2,e2**2) *  &
          (1 - enclosed_angle_ct(prt_get_momentum (prt1), &
          prt_get_momentum (prt2)))
   end function obs_ktmeasure
 
 @ %def obs_ktmeasure
Index: trunk/src/process_integration/process_integration.nw
===================================================================
--- trunk/src/process_integration/process_integration.nw	(revision 8163)
+++ trunk/src/process_integration/process_integration.nw	(revision 8164)
@@ -1,17843 +1,17856 @@
 % -*- ess-noweb-default-code-mode: f90-mode; noweb-default-code-mode: f90-mode; -*-
 % WHIZARD code as NOWEB source: integration and process objects and such
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Integration and Process Objects}
 \includemodulegraph{process_integration}
 
 This is the central part of the \whizard\ package.  It provides the
 functionality for evaluating structure functions, kinematics and matrix
 elements, integration and event generation.  It combines the various
 parts that deal with those tasks individually and organizes the data
 transfer between them.
 
 \begin{description}
 \item[subevt\_expr]
   This enables process observables as (abstract) expressions, to be
   evaluated for each process call.
 \item[parton\_states]
   A [[parton_state_t]] object represents an elementary partonic
   interaction.  There are two versions: one for the isolated
   elementary process, one for the elementary process convoluted with
   the structure-function chain.  The parton state is an effective
   state.  It needs not coincide with the seed-kinematics state which is
   used in evaluating phase space.
 \item[process]
   Here, all pieces are combined for the purpose of evaluating the
   elementary processes.  The whole algorithm is coded in terms of
   abstract data types as defined in the appropriate modules: [[prc_core]]
   for matrix-element evaluation, [[prc_core_def]] for the associated
   configuration and driver, [[sf_base]] for beams and structure-functions,
   [[phs_base]] for phase space, and [[mci_base]] for integration and event
   generation.
 \item[process\_config]
 \item[process\_counter]
   Very simple object for statistics
 \item[process\_mci]
 \item[pcm]
 \item[kinematics]
 \item[instances]
   While the above modules set up all static information, the instances
   have the changing event data. There are term and process instances but
   no component instances.
 \item[process\_stacks]
   Process stacks collect process objects.
 \end{description}
 
 We combine here hard interactions, phase space, and (for scatterings)
 structure functions and interfaces them to the integration module.
 
 The process object implements the combination of a fixed beam and
 structure-function setup with a number of elementary processes.  The
 latter are called process components.  The process object
 represents an entity which is supposedly observable.  It should
 be meaningful to talk about the cross section of a process.
 
 The individual components of a process are, technically, processes
 themselves, but they may have unphysical cross sections which have to
 be added for a physical result.  Process components may be exclusive
 tree-level elementary processes, dipole subtraction term, loop
 corrections, etc.
 
 The beam and structure function setup is common to all process
 components.  Thus, there is only one instance of this part.
 
 The process may be a scattering process or a decay process.  In the
 latter case, there are no structure functions, and the beam setup
 consists of a single particle.  Otherwise, the two classes are treated
 on the same footing.
 
 Once a sampling point has been chosen, a process determines a set of
 partons with a correlated density matrix of quantum numbers.  In
 general, each sampling point will generate, for each process component,
 one or more distinct parton configurations.  This is the [[computed]]
 state.  The computed state is the subject of the multi-channel
 integration algorithm.
 
 For NLO computations, it is necessary to project the computed states
 onto another set of parton configurations (e.g., by recombining
 certain pairs).  This is the [[observed]] state.  When computing
 partonic observables, the information is taken from the observed
 state.
 
 For the purpose of event generation, we will later select one parton
 configuration from the observed state and collapse the correlated
 quantum state.  This configuration is then dressed by applying parton
 shower, decays and hadronization.  The decay chain, in particular,
 combines a scattering process with possible subsequent decay processes
 on the parton level, which are full-fledged process objects themselves.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Process observables}
 We define an abstract [[subevt_expr_t]] object as an extension of the
 [[subevt_t]] type.  The object contains a local variable list, variable
 instances (as targets for pointers in the variable list), and evaluation
 trees.  The evaluation trees reference both the variables and the [[subevt]].
 
 There are two instances of the abstract type: one for process instances, one
 for physical events.  Both have a common logical expression [[selection]]
 which determines whether the object passes user-defined cuts.
 
 The intention is that we fill the [[subevt_t]] base object and compute the
 variables once we have evaluated a kinematical phase space point (or a
 complete event).  We then evaluate the expressions and can use the results in
 further calculations.
 
 The [[process_expr_t]] extension contains furthermore scale and weight
 expressions.  The [[event_expr_t]] extension contains a reweighting-factor
 expression and a logical expression for event analysis.  In practice, we will
 link the variable list of the [[event_obs]] object to the variable list of the
 currently active [[process_obs]] object, such that the process variables are
 available to both objects.  Event variables are meaningful only for physical
 events.
 
 Note that there are unit tests, but they are deferred to the
 [[expr_tests]] module.
 <<[[subevt_expr.f90]]>>=
 <<File header>>
 module subevt_expr
 
 <<Use kinds>>
 <<Use strings>>
   use constants, only: zero, one
   use io_units
   use format_utils, only: write_separator
   use diagnostics
   use lorentz
   use subevents
   use variables
   use flavors
   use quantum_numbers
   use interactions
   use particles
   use expr_base
 
 <<Standard module head>>
 
 <<Subevt expr: public>>
 
 <<Subevt expr: types>>
 
 <<Subevt expr: interfaces>>
 
 contains
 
 <<Subevt expr: procedures>>
 
 end module subevt_expr
 @ %def subevt_expr
 @
 \subsection{Abstract base type}
 <<Subevt expr: types>>=
   type, extends (subevt_t), abstract :: subevt_expr_t
      logical :: subevt_filled = .false.
      type(var_list_t) :: var_list
      real(default) :: sqrts_hat = 0
      integer :: n_in = 0
      integer :: n_out = 0
      integer :: n_tot = 0
      logical :: has_selection = .false.
      class(expr_t), allocatable :: selection
+     logical :: colorize_subevt = .false.
    contains
    <<Subevt expr: subevt expr: TBP>>
   end type subevt_expr_t
 
 @ %def subevt_expr_t
 @ Output: Base and extended version.  We already have a [[write]] routine for
 the [[subevt_t]] parent type.
 <<Subevt expr: subevt expr: TBP>>=
   procedure :: base_write => subevt_expr_write
 <<Subevt expr: procedures>>=
   subroutine subevt_expr_write (object, unit, pacified)
     class(subevt_expr_t), intent(in) :: object
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: pacified
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A)")  "Local variables:"
     call write_separator (u)
     call var_list_write (object%var_list, u, follow_link=.false., &
          pacified = pacified)
     call write_separator (u)
     if (object%subevt_filled) then
        call object%subevt_t%write (u, pacified = pacified)
        if (object%has_selection) then
           call write_separator (u)
           write (u, "(1x,A)")  "Selection expression:"
           call write_separator (u)
           call object%selection%write (u)
        end if
     else
        write (u, "(1x,A)")  "subevt: [undefined]"
     end if
   end subroutine subevt_expr_write
 
 @ %def subevt_expr_write
 @ Finalizer.
 <<Subevt expr: subevt expr: TBP>>=
   procedure (subevt_expr_final), deferred :: final
   procedure :: base_final => subevt_expr_final
 <<Subevt expr: procedures>>=
   subroutine subevt_expr_final (object)
     class(subevt_expr_t), intent(inout) :: object
     call object%var_list%final ()
     if (object%has_selection) then
        call object%selection%final ()
     end if
   end subroutine subevt_expr_final
 
 @ %def subevt_expr_final
 @
 \subsection{Initialization}
 Initialization: define local variables and establish pointers.
 
 The common variables are [[sqrts]] (the nominal beam energy, fixed),
 [[sqrts_hat]] (the actual energy), [[n_in]], [[n_out]], and [[n_tot]] for
 the [[subevt]].  With the exception of [[sqrts]], all are implemented as
 pointers to subobjects.
 <<Subevt expr: subevt expr: TBP>>=
   procedure (subevt_expr_setup_vars), deferred :: setup_vars
   procedure :: base_setup_vars => subevt_expr_setup_vars
 <<Subevt expr: procedures>>=
   subroutine subevt_expr_setup_vars (expr, sqrts)
     class(subevt_expr_t), intent(inout), target :: expr
     real(default), intent(in) :: sqrts
     call expr%var_list%final ()
     call var_list_append_real (expr%var_list, &
          var_str ("sqrts"), sqrts, &
          locked = .true., verbose = .false., intrinsic = .true.)
     call var_list_append_real_ptr (expr%var_list, &
          var_str ("sqrts_hat"), expr%sqrts_hat, &
          is_known = expr%subevt_filled, &
          locked = .true., verbose = .false., intrinsic = .true.)
     call var_list_append_int_ptr (expr%var_list, &
          var_str ("n_in"), expr%n_in, &
          is_known = expr%subevt_filled, &
          locked = .true., verbose = .false., intrinsic = .true.)
     call var_list_append_int_ptr (expr%var_list, &
          var_str ("n_out"), expr%n_out, &
          is_known = expr%subevt_filled, &
          locked = .true., verbose = .false., intrinsic = .true.)
     call var_list_append_int_ptr (expr%var_list, &
          var_str ("n_tot"), expr%n_tot, &
          is_known = expr%subevt_filled, &
          locked = .true., verbose = .false., intrinsic = .true.)
   end subroutine subevt_expr_setup_vars
 
 @ %def subevt_expr_setup_vars
 @ Append the subevent expr (its base-type core) itself to the variable
 list, if it is not yet present.
 <<Subevt expr: subevt expr: TBP>>=
   procedure :: setup_var_self => subevt_expr_setup_var_self
 <<Subevt expr: procedures>>=
   subroutine subevt_expr_setup_var_self (expr)
     class(subevt_expr_t), intent(inout), target :: expr
     if (.not. expr%var_list%contains (var_str ("@evt"))) then
        call var_list_append_subevt_ptr &
             (expr%var_list, &
             var_str ("@evt"), expr%subevt_t, &
             is_known = expr%subevt_filled, &
             locked = .true., verbose = .false., intrinsic=.true.)
     end if
   end subroutine subevt_expr_setup_var_self
 
 @ %def subevt_expr_setup_var_self
 @ Link a variable list to the local one.  This could be done event by event,
 but before evaluating expressions.
 <<Subevt expr: subevt expr: TBP>>=
   procedure :: link_var_list => subevt_expr_link_var_list
 <<Subevt expr: procedures>>=
   subroutine subevt_expr_link_var_list (expr, var_list)
     class(subevt_expr_t), intent(inout) :: expr
     type(var_list_t), intent(in), target :: var_list
     call expr%var_list%link (var_list)
   end subroutine subevt_expr_link_var_list
 
 @ %def subevt_expr_link_var_list
 @ Compile the selection expression.  If there is no expression, the build
 method won't allocate the expression object.
 <<Subevt expr: subevt expr: TBP>>=
   procedure :: setup_selection => subevt_expr_setup_selection
 <<Subevt expr: procedures>>=
   subroutine subevt_expr_setup_selection (expr, ef_cuts)
     class(subevt_expr_t), intent(inout), target :: expr
     class(expr_factory_t), intent(in) :: ef_cuts
     call ef_cuts%build (expr%selection)
     if (allocated (expr%selection)) then
        call expr%setup_var_self ()
        call expr%selection%setup_lexpr (expr%var_list)
        expr%has_selection = .true.
     end if
   end subroutine subevt_expr_setup_selection
 
 @ %def subevt_expr_setup_selection
+@ (De)activate color storage and evaluation for the expression.  The subevent
+particles will have color information.
+<<Subevt expr: subevt expr: TBP>>=
+  procedure :: colorize => subevt_expr_colorize
+<<Subevt expr: procedures>>=
+  subroutine subevt_expr_colorize (expr, colorize_subevt)
+    class(subevt_expr_t), intent(inout), target :: expr
+    logical, intent(in) :: colorize_subevt
+    expr%colorize_subevt = colorize_subevt
+  end subroutine subevt_expr_colorize
+    
+@ %def subevt_expr_colorize
 @
 \subsection{Evaluation}
 Reset to initial state, i.e., mark the [[subevt]] as invalid.
 <<Subevt expr: subevt expr: TBP>>=
   procedure :: reset_contents => subevt_expr_reset_contents
   procedure :: base_reset_contents => subevt_expr_reset_contents
 <<Subevt expr: procedures>>=
   subroutine subevt_expr_reset_contents (expr)
     class(subevt_expr_t), intent(inout) :: expr
     expr%subevt_filled = .false.
   end subroutine subevt_expr_reset_contents
 
 @ %def subevt_expr_reset_contents
 @ Evaluate the selection expression and return the result.  There is also a
 deferred version: this should evaluate the remaining expressions if the event
 has passed.
 <<Subevt expr: subevt expr: TBP>>=
   procedure :: base_evaluate => subevt_expr_evaluate
 <<Subevt expr: procedures>>=
   subroutine subevt_expr_evaluate (expr, passed)
     class(subevt_expr_t), intent(inout) :: expr
     logical, intent(out) :: passed
     if (expr%has_selection) then
        call expr%selection%evaluate ()
        if (expr%selection%is_known ()) then
           passed = expr%selection%get_log ()
        else
           call msg_error ("Evaluate selection expression: result undefined")
           passed = .false.
        end if
     else
        passed = .true.
     end if
   end subroutine subevt_expr_evaluate
 
 @ %def subevt_expr_evaluate
 @
 \subsection{Implementation for partonic events}
 This implementation contains the expressions that we can evaluate for the
 partonic process during integration.
 <<Subevt expr: public>>=
   public :: parton_expr_t
 <<Subevt expr: types>>=
   type, extends (subevt_expr_t) :: parton_expr_t
      integer, dimension(:), allocatable :: i_beam
      integer, dimension(:), allocatable :: i_in
      integer, dimension(:), allocatable :: i_out
      logical :: has_scale = .false.
      logical :: has_fac_scale = .false.
      logical :: has_ren_scale = .false.
      logical :: has_weight = .false.
      class(expr_t), allocatable :: scale
      class(expr_t), allocatable :: fac_scale
      class(expr_t), allocatable :: ren_scale
      class(expr_t), allocatable :: weight
    contains
    <<Subevt expr: parton expr: TBP>>
   end type parton_expr_t
 
 @ %def parton_expr_t
 @ Finalizer.
 <<Subevt expr: parton expr: TBP>>=
   procedure :: final => parton_expr_final
 <<Subevt expr: procedures>>=
   subroutine parton_expr_final (object)
     class(parton_expr_t), intent(inout) :: object
     call object%base_final ()
     if (object%has_scale) then
        call object%scale%final ()
     end if
     if (object%has_fac_scale) then
        call object%fac_scale%final ()
     end if
     if (object%has_ren_scale) then
        call object%ren_scale%final ()
     end if
     if (object%has_weight) then
        call object%weight%final ()
     end if
   end subroutine parton_expr_final
 
 @ %def parton_expr_final
 @ Output: continue writing the active expressions, after the common selection
 expression.
 
 Note: the [[prefix]] argument is declared in the [[write]] method of the
 [[subevt_t]] base type.  Here, it is unused.
 <<Subevt expr: parton expr: TBP>>=
   procedure :: write => parton_expr_write
 <<Subevt expr: procedures>>=
   subroutine parton_expr_write (object, unit, prefix, pacified)
     class(parton_expr_t), intent(in) :: object
     integer, intent(in), optional :: unit
     character(*), intent(in), optional :: prefix
     logical, intent(in), optional :: pacified
     integer :: u
     u = given_output_unit (unit)
     call object%base_write (u, pacified = pacified)
     if (object%subevt_filled) then
        if (object%has_scale) then
           call write_separator (u)
           write (u, "(1x,A)")  "Scale expression:"
           call write_separator (u)
           call object%scale%write (u)
        end if
        if (object%has_fac_scale) then
           call write_separator (u)
           write (u, "(1x,A)")  "Factorization scale expression:"
           call write_separator (u)
           call object%fac_scale%write (u)
        end if
        if (object%has_ren_scale) then
           call write_separator (u)
           write (u, "(1x,A)")  "Renormalization scale expression:"
           call write_separator (u)
           call object%ren_scale%write (u)
        end if
        if (object%has_weight) then
           call write_separator (u)
           write (u, "(1x,A)")  "Weight expression:"
           call write_separator (u)
           call object%weight%write (u)
        end if
     end if
   end subroutine parton_expr_write
 
 @ %def parton_expr_write
 @ Define variables.
 <<Subevt expr: parton expr: TBP>>=
   procedure :: setup_vars => parton_expr_setup_vars
 <<Subevt expr: procedures>>=
   subroutine parton_expr_setup_vars (expr, sqrts)
     class(parton_expr_t), intent(inout), target :: expr
     real(default), intent(in) :: sqrts
     call expr%base_setup_vars (sqrts)
   end subroutine parton_expr_setup_vars
 
 @ %def parton_expr_setup_vars
 @ Compile the scale expressions.  If a pointer is disassociated, there is
 no expression.
 <<Subevt expr: parton expr: TBP>>=
   procedure :: setup_scale => parton_expr_setup_scale
   procedure :: setup_fac_scale => parton_expr_setup_fac_scale
   procedure :: setup_ren_scale => parton_expr_setup_ren_scale
 <<Subevt expr: procedures>>=
   subroutine parton_expr_setup_scale (expr, ef_scale)
     class(parton_expr_t), intent(inout), target :: expr
     class(expr_factory_t), intent(in) :: ef_scale
     call ef_scale%build (expr%scale)
     if (allocated (expr%scale)) then
        call expr%setup_var_self ()
        call expr%scale%setup_expr (expr%var_list)
        expr%has_scale = .true.
     end if
   end subroutine parton_expr_setup_scale
 
   subroutine parton_expr_setup_fac_scale (expr, ef_fac_scale)
     class(parton_expr_t), intent(inout), target :: expr
     class(expr_factory_t), intent(in) :: ef_fac_scale
     call ef_fac_scale%build (expr%fac_scale)
     if (allocated (expr%fac_scale)) then
        call expr%setup_var_self ()
        call expr%fac_scale%setup_expr (expr%var_list)
        expr%has_fac_scale = .true.
     end if
   end subroutine parton_expr_setup_fac_scale
 
   subroutine parton_expr_setup_ren_scale (expr, ef_ren_scale)
     class(parton_expr_t), intent(inout), target :: expr
     class(expr_factory_t), intent(in) :: ef_ren_scale
     call ef_ren_scale%build (expr%ren_scale)
     if (allocated (expr%ren_scale)) then
        call expr%setup_var_self ()
        call expr%ren_scale%setup_expr (expr%var_list)
        expr%has_ren_scale = .true.
     end if
   end subroutine parton_expr_setup_ren_scale
 
 @ %def parton_expr_setup_scale
 @ %def parton_expr_setup_fac_scale
 @ %def parton_expr_setup_ren_scale
 @ Compile the weight expression.
 <<Subevt expr: parton expr: TBP>>=
   procedure :: setup_weight => parton_expr_setup_weight
 <<Subevt expr: procedures>>=
   subroutine parton_expr_setup_weight (expr, ef_weight)
     class(parton_expr_t), intent(inout), target :: expr
     class(expr_factory_t), intent(in) :: ef_weight
     call ef_weight%build (expr%weight)
     if (allocated (expr%weight)) then
        call expr%setup_var_self ()
        call expr%weight%setup_expr (expr%var_list)
        expr%has_weight = .true.
     end if
   end subroutine parton_expr_setup_weight
 
 @ %def parton_expr_setup_weight
 @ Filling the partonic state consists of two parts.  The first routine
 prepares the subevt without assigning momenta.  It takes the particles from an
 [[interaction_t]].  It needs the indices and flavors for the beam,
 incoming, and outgoing particles.
 
 We can assume that the particle content of the subevt does not change.
 Therefore, we set the event variables [[n_in]], [[n_out]], [[n_tot]] already
 in this initialization step.
 <<Subevt expr: parton expr: TBP>>=
   procedure :: setup_subevt => parton_expr_setup_subevt
 <<Subevt expr: procedures>>=
   subroutine parton_expr_setup_subevt (expr, int, &
        i_beam, i_in, i_out, f_beam, f_in, f_out)
     class(parton_expr_t), intent(inout) :: expr
     type(interaction_t), intent(in), target :: int
     integer, dimension(:), intent(in) :: i_beam, i_in, i_out
     type(flavor_t), dimension(:), intent(in) :: f_beam, f_in, f_out
     allocate (expr%i_beam (size (i_beam)))
     allocate (expr%i_in (size (i_in)))
     allocate (expr%i_out (size (i_out)))
     expr%i_beam = i_beam
     expr%i_in = i_in
     expr%i_out = i_out
     call interaction_to_subevt (int, &
          expr%i_beam, expr%i_in, expr%i_out, expr%subevt_t)
     call subevt_set_pdg_beam     (expr%subevt_t, f_beam%get_pdg ())
     call subevt_set_pdg_incoming (expr%subevt_t, f_in%get_pdg ())
     call subevt_set_pdg_outgoing (expr%subevt_t, f_out%get_pdg ())
     call subevt_set_p2_beam     (expr%subevt_t, f_beam%get_mass () ** 2)
     call subevt_set_p2_incoming (expr%subevt_t, f_in%get_mass ()   ** 2)
     call subevt_set_p2_outgoing (expr%subevt_t, f_out%get_mass ()  ** 2)
     expr%n_in  = size (i_in)
     expr%n_out = size (i_out)
     expr%n_tot = expr%n_in + expr%n_out
   end subroutine parton_expr_setup_subevt
 
 @ %def parton_expr_setup_subevt
 @ Transfer PDG codes, masses (initalization) and momenta to a
 predefined subevent.  We use the flavor assignment of the first
 branch in the interaction state matrix.  Only incoming and outgoing
 particles are transferred.  Switch momentum sign for incoming
 particles.
 <<Subevt expr: interfaces>>=
   interface interaction_momenta_to_subevt
      module procedure interaction_momenta_to_subevt_id
      module procedure interaction_momenta_to_subevt_tr
   end interface
 
 <<Subevt expr: procedures>>=
   subroutine interaction_to_subevt (int, j_beam, j_in, j_out, subevt)
     type(interaction_t), intent(in), target :: int
     integer, dimension(:), intent(in) :: j_beam, j_in, j_out
     type(subevt_t), intent(out) :: subevt
     type(flavor_t), dimension(:), allocatable :: flv
     integer :: n_beam, n_in, n_out, i, j
     allocate (flv (int%get_n_tot ()))
     flv = quantum_numbers_get_flavor (int%get_quantum_numbers (1))
     n_beam = size (j_beam)
     n_in = size (j_in)
     n_out = size (j_out)
     call subevt_init (subevt, n_beam + n_in + n_out)
     do i = 1, n_beam
        j = j_beam(i)
        call subevt_set_beam (subevt, i, &
             flv(j)%get_pdg (), &
             vector4_null, &
             flv(j)%get_mass () ** 2)
     end do
     do i = 1, n_in
        j = j_in(i)
        call subevt_set_incoming (subevt, n_beam + i, &
             flv(j)%get_pdg (), &
             vector4_null, &
             flv(j)%get_mass () ** 2)
     end do
     do i = 1, n_out
        j = j_out(i)
        call subevt_set_outgoing (subevt, n_beam + n_in + i, &
             flv(j)%get_pdg (), &
             vector4_null, &
             flv(j)%get_mass () ** 2)
     end do
   end subroutine interaction_to_subevt
 
   subroutine interaction_momenta_to_subevt_id (int, j_beam, j_in, j_out, subevt)
     type(interaction_t), intent(in) :: int
     integer, dimension(:), intent(in) :: j_beam, j_in, j_out
     type(subevt_t), intent(inout) :: subevt
     call subevt_set_p_beam (subevt, - int%get_momenta (j_beam))
     call subevt_set_p_incoming (subevt, - int%get_momenta (j_in))
     call subevt_set_p_outgoing (subevt, int%get_momenta (j_out))
   end subroutine interaction_momenta_to_subevt_id
 
   subroutine interaction_momenta_to_subevt_tr &
        (int, j_beam, j_in, j_out, lt, subevt)
     type(interaction_t), intent(in) :: int
     integer, dimension(:), intent(in) :: j_beam, j_in, j_out
     type(subevt_t), intent(inout) :: subevt
     type(lorentz_transformation_t), intent(in) :: lt
     call subevt_set_p_beam &
          (subevt, - lt * int%get_momenta (j_beam))
     call subevt_set_p_incoming &
          (subevt, - lt * int%get_momenta (j_in))
     call subevt_set_p_outgoing &
          (subevt, lt * int%get_momenta (j_out))
   end subroutine interaction_momenta_to_subevt_tr
 
 @ %def interaction_momenta_to_subevt
 @ The second part takes the momenta from the interaction object and thus
 completes the subevt.  The partonic energy can then be computed.
 <<Subevt expr: parton expr: TBP>>=
   procedure :: fill_subevt => parton_expr_fill_subevt
 <<Subevt expr: procedures>>=
   subroutine parton_expr_fill_subevt (expr, int)
     class(parton_expr_t), intent(inout) :: expr
     type(interaction_t), intent(in), target :: int
     call interaction_momenta_to_subevt (int, &
          expr%i_beam, expr%i_in, expr%i_out, expr%subevt_t)
     expr%sqrts_hat = subevt_get_sqrts_hat (expr%subevt_t)
     expr%subevt_filled = .true.
   end subroutine parton_expr_fill_subevt
 
 @ %def parton_expr_fill_subevt
 @ Evaluate, if the event passes the selection.  For absent expressions we take
 default values.
 <<Subevt expr: parton expr: TBP>>=
   procedure :: evaluate => parton_expr_evaluate
 <<Subevt expr: procedures>>=
   subroutine parton_expr_evaluate &
        (expr, passed, scale, fac_scale, ren_scale, weight, scale_forced, force_evaluation)
     class(parton_expr_t), intent(inout) :: expr
     logical, intent(out) :: passed
     real(default), intent(out) :: scale
     real(default), intent(out) :: fac_scale
     real(default), intent(out) :: ren_scale
     real(default), intent(out) :: weight
     real(default), intent(in), allocatable, optional :: scale_forced
     logical, intent(in), optional :: force_evaluation
     logical :: force_scale, force_eval
     force_scale = .false.; force_eval = .false.
     if (present (scale_forced))  force_scale = allocated (scale_forced)
     if (present (force_evaluation)) force_eval = force_evaluation
     call expr%base_evaluate (passed)
     if (passed .or. force_eval) then
        if (force_scale) then
           scale = scale_forced
        else if (expr%has_scale) then
           call expr%scale%evaluate ()
           if (expr%scale%is_known ()) then
              scale = expr%scale%get_real ()
           else
              call msg_error ("Evaluate scale expression: result undefined")
              scale = zero
           end if
        else
           scale = expr%sqrts_hat
        end if
        if (force_scale) then
           fac_scale = scale_forced
        else if (expr%has_fac_scale) then
           call expr%fac_scale%evaluate ()
           if (expr%fac_scale%is_known ()) then
              fac_scale = expr%fac_scale%get_real ()
           else
              call msg_error ("Evaluate factorization scale expression: &
                   &result undefined")
              fac_scale = zero
           end if
        else
           fac_scale = scale
        end if
        if (force_scale) then
           ren_scale = scale_forced
        else if (expr%has_ren_scale) then
           call expr%ren_scale%evaluate ()
           if (expr%ren_scale%is_known ()) then
              ren_scale = expr%ren_scale%get_real ()
           else
              call msg_error ("Evaluate renormalization scale expression: &
                   &result undefined")
              ren_scale = zero
           end if
        else
           ren_scale = scale
        end if
        if (expr%has_weight) then
           call expr%weight%evaluate ()
           if (expr%weight%is_known ()) then
              weight = expr%weight%get_real ()
           else
              call msg_error ("Evaluate weight expression: result undefined")
              weight = zero
           end if
        else
           weight = one
        end if
     else
        weight = zero
     end if
   end subroutine parton_expr_evaluate
 
 @ %def parton_expr_evaluate
 @ Return the beam/incoming parton indices.
 <<Subevt expr: parton expr: TBP>>=
   procedure :: get_beam_index => parton_expr_get_beam_index
   procedure :: get_in_index => parton_expr_get_in_index
 <<Subevt expr: procedures>>=
   subroutine parton_expr_get_beam_index (expr, i_beam)
     class(parton_expr_t), intent(in) :: expr
     integer, dimension(:), intent(out) :: i_beam
     i_beam = expr%i_beam
   end subroutine parton_expr_get_beam_index
 
   subroutine parton_expr_get_in_index (expr, i_in)
     class(parton_expr_t), intent(in) :: expr
     integer, dimension(:), intent(out) :: i_in
     i_in = expr%i_in
   end subroutine parton_expr_get_in_index
 
 @ %def parton_expr_get_beam_index
 @ %def parton_expr_get_in_index
 @
 \subsection{Implementation for full events}
 This implementation contains the expressions that we can evaluate for the
 full event.  It also contains data that pertain to the event, suitable
 for communication with external event formats.  These data
 simultaneously serve as pointer targets for the variable lists hidden
 in the expressions (eval trees).
 
 Squared matrix element and weight values: when reading events from
 file, the [[ref]] value is the number in the file, while the [[prc]]
 value is the number that we calculate from the momenta in the file,
 possibly with different parameters.  When generating events the first
 time, or if we do not recalculate, the numbers should coincide.
 Furthermore, the array of [[alt]] values is copied from an array of
 alternative event records.  These values should represent calculated
 values.
 <<Subevt expr: public>>=
   public :: event_expr_t
 <<Subevt expr: types>>=
   type, extends (subevt_expr_t) :: event_expr_t
      logical :: has_reweight = .false.
      logical :: has_analysis = .false.
      class(expr_t), allocatable :: reweight
      class(expr_t), allocatable :: analysis
      logical :: has_id = .false.
      type(string_t) :: id
      logical :: has_num_id = .false.
      integer :: num_id = 0
      logical :: has_index = .false.
      integer :: index = 0
      logical :: has_sqme_ref = .false.
      real(default) :: sqme_ref = 0
      logical :: has_sqme_prc = .false.
      real(default) :: sqme_prc = 0
      logical :: has_weight_ref = .false.
      real(default) :: weight_ref = 0
      logical :: has_weight_prc = .false.
      real(default) :: weight_prc = 0
      logical :: has_excess_prc = .false.
      real(default) :: excess_prc = 0
      integer :: n_alt = 0
      logical :: has_sqme_alt = .false.
      real(default), dimension(:), allocatable :: sqme_alt
      logical :: has_weight_alt = .false.
      real(default), dimension(:), allocatable :: weight_alt
    contains
    <<Subevt expr: event expr: TBP>>
   end type event_expr_t
 
 @ %def event_expr_t
 @ Finalizer for the expressions.
 <<Subevt expr: event expr: TBP>>=
   procedure :: final => event_expr_final
 <<Subevt expr: procedures>>=
   subroutine event_expr_final (object)
     class(event_expr_t), intent(inout) :: object
     call object%base_final ()
     if (object%has_reweight) then
        call object%reweight%final ()
     end if
     if (object%has_analysis) then
        call object%analysis%final ()
     end if
   end subroutine event_expr_final
 
 @ %def event_expr_final
 @ Output: continue writing the active expressions, after the common selection
 expression.
 
 Note: the [[prefix]] argument is declared in the [[write]] method of the
 [[subevt_t]] base type.  Here, it is unused.
 <<Subevt expr: event expr: TBP>>=
   procedure :: write => event_expr_write
 <<Subevt expr: procedures>>=
   subroutine event_expr_write (object, unit, prefix, pacified)
     class(event_expr_t), intent(in) :: object
     integer, intent(in), optional :: unit
     character(*), intent(in), optional :: prefix
     logical, intent(in), optional :: pacified
     integer :: u
     u = given_output_unit (unit)
     call object%base_write (u, pacified = pacified)
     if (object%subevt_filled) then
        if (object%has_reweight) then
           call write_separator (u)
           write (u, "(1x,A)")  "Reweighting expression:"
           call write_separator (u)
           call object%reweight%write (u)
        end if
        if (object%has_analysis) then
           call write_separator (u)
           write (u, "(1x,A)")  "Analysis expression:"
           call write_separator (u)
           call object%analysis%write (u)
        end if
     end if
   end subroutine event_expr_write
 
 @ %def event_expr_write
 @ Initializer.  This is required only for the [[sqme_alt]] and
 [[weight_alt]] arrays.
 <<Subevt expr: event expr: TBP>>=
   procedure :: init => event_expr_init
 <<Subevt expr: procedures>>=
   subroutine event_expr_init (expr, n_alt)
     class(event_expr_t), intent(out) :: expr
     integer, intent(in), optional :: n_alt
     if (present (n_alt)) then
        expr%n_alt = n_alt
        allocate (expr%sqme_alt (n_alt), source = 0._default)
        allocate (expr%weight_alt (n_alt), source = 0._default)
     end if
   end subroutine event_expr_init
 
 @ %def event_expr_init
 @ Define variables.  We have the variables of the base type plus
 specific variables for full events.  There is the event index.
 <<Subevt expr: event expr: TBP>>=
   procedure :: setup_vars => event_expr_setup_vars
 <<Subevt expr: procedures>>=
   subroutine event_expr_setup_vars (expr, sqrts)
     class(event_expr_t), intent(inout), target :: expr
     real(default), intent(in) :: sqrts
     call expr%base_setup_vars (sqrts)
     call var_list_append_string_ptr (expr%var_list, &
          var_str ("$process_id"), expr%id, &
          is_known = expr%has_id, &
          locked = .true., verbose = .false., intrinsic = .true.)
     call var_list_append_int_ptr (expr%var_list, &
          var_str ("process_num_id"), expr%num_id, &
          is_known = expr%has_num_id, &
          locked = .true., verbose = .false., intrinsic = .true.)
     call var_list_append_real_ptr (expr%var_list, &
          var_str ("sqme"), expr%sqme_prc, &
          is_known = expr%has_sqme_prc, &
          locked = .true., verbose = .false., intrinsic = .true.)
     call var_list_append_real_ptr (expr%var_list, &
          var_str ("sqme_ref"), expr%sqme_ref, &
          is_known = expr%has_sqme_ref, &
          locked = .true., verbose = .false., intrinsic = .true.)
     call var_list_append_int_ptr (expr%var_list, &
          var_str ("event_index"), expr%index, &
          is_known = expr%has_index, &
          locked = .true., verbose = .false., intrinsic = .true.)
     call var_list_append_real_ptr (expr%var_list, &
          var_str ("event_weight"), expr%weight_prc, &
          is_known = expr%has_weight_prc, &
          locked = .true., verbose = .false., intrinsic = .true.)
     call var_list_append_real_ptr (expr%var_list, &
          var_str ("event_weight_ref"), expr%weight_ref, &
          is_known = expr%has_weight_ref, &
          locked = .true., verbose = .false., intrinsic = .true.)
     call var_list_append_real_ptr (expr%var_list, &
          var_str ("event_excess"), expr%excess_prc, &
          is_known = expr%has_excess_prc, &
          locked = .true., verbose = .false., intrinsic = .true.)
   end subroutine event_expr_setup_vars
 
 @ %def event_expr_setup_vars
 @ Compile the analysis expression.  If the pointer is disassociated, there is
 no expression.
 <<Subevt expr: event expr: TBP>>=
   procedure :: setup_analysis => event_expr_setup_analysis
 <<Subevt expr: procedures>>=
   subroutine event_expr_setup_analysis (expr, ef_analysis)
     class(event_expr_t), intent(inout), target :: expr
     class(expr_factory_t), intent(in) :: ef_analysis
     call ef_analysis%build (expr%analysis)
     if (allocated (expr%analysis)) then
        call expr%setup_var_self ()
        call expr%analysis%setup_lexpr (expr%var_list)
        expr%has_analysis = .true.
     end if
   end subroutine event_expr_setup_analysis
 
 @ %def event_expr_setup_analysis
 @ Compile the reweight expression.
 <<Subevt expr: event expr: TBP>>=
   procedure :: setup_reweight => event_expr_setup_reweight
 <<Subevt expr: procedures>>=
   subroutine event_expr_setup_reweight (expr, ef_reweight)
     class(event_expr_t), intent(inout), target :: expr
     class(expr_factory_t), intent(in) :: ef_reweight
     call ef_reweight%build (expr%reweight)
     if (allocated (expr%reweight)) then
        call expr%setup_var_self ()
        call expr%reweight%setup_expr (expr%var_list)
        expr%has_reweight = .true.
     end if
   end subroutine event_expr_setup_reweight
 
 @ %def event_expr_setup_reweight
 @ Store the string or numeric process ID.  This should be done during
 initialization.
 <<Subevt expr: event expr: TBP>>=
   procedure :: set_process_id => event_expr_set_process_id
   procedure :: set_process_num_id => event_expr_set_process_num_id
 <<Subevt expr: procedures>>=
   subroutine event_expr_set_process_id (expr, id)
     class(event_expr_t), intent(inout) :: expr
     type(string_t), intent(in) :: id
     expr%id = id
     expr%has_id = .true.
   end subroutine event_expr_set_process_id
 
   subroutine event_expr_set_process_num_id (expr, num_id)
     class(event_expr_t), intent(inout) :: expr
     integer, intent(in) :: num_id
     expr%num_id = num_id
     expr%has_num_id = .true.
   end subroutine event_expr_set_process_num_id
 
 @ %def event_expr_set_process_id
 @ %def event_expr_set_process_num_id
 @ Reset / set the data that pertain to a particular event.  The event
 index is reset unless explicitly told to keep it.
 <<Subevt expr: event expr: TBP>>=
   procedure :: reset_contents => event_expr_reset_contents
   procedure :: set => event_expr_set
 <<Subevt expr: procedures>>=
   subroutine event_expr_reset_contents (expr)
     class(event_expr_t), intent(inout) :: expr
     call expr%base_reset_contents ()
     expr%has_sqme_ref = .false.
     expr%has_sqme_prc = .false.
     expr%has_sqme_alt = .false.
     expr%has_weight_ref = .false.
     expr%has_weight_prc = .false.
     expr%has_weight_alt = .false.
     expr%has_excess_prc = .false.
   end subroutine event_expr_reset_contents
 
   subroutine event_expr_set (expr, &
        weight_ref, weight_prc, weight_alt, &
        excess_prc, &
        sqme_ref, sqme_prc, sqme_alt)
     class(event_expr_t), intent(inout) :: expr
     real(default), intent(in), optional :: weight_ref, weight_prc
     real(default), intent(in), optional :: excess_prc
     real(default), intent(in), optional :: sqme_ref, sqme_prc
     real(default), dimension(:), intent(in), optional :: sqme_alt, weight_alt
     if (present (sqme_ref)) then
        expr%has_sqme_ref = .true.
        expr%sqme_ref = sqme_ref
     end if
     if (present (sqme_prc)) then
        expr%has_sqme_prc = .true.
        expr%sqme_prc = sqme_prc
     end if
     if (present (sqme_alt)) then
        expr%has_sqme_alt = .true.
        expr%sqme_alt = sqme_alt
     end if
     if (present (weight_ref)) then
        expr%has_weight_ref = .true.
        expr%weight_ref = weight_ref
     end if
     if (present (weight_prc)) then
        expr%has_weight_prc = .true.
        expr%weight_prc = weight_prc
     end if
     if (present (weight_alt)) then
        expr%has_weight_alt = .true.
        expr%weight_alt = weight_alt
     end if
     if (present (excess_prc)) then
        expr%has_excess_prc = .true.
        expr%excess_prc = excess_prc
     end if
   end subroutine event_expr_set
 
 @ %def event_expr_reset_contents event_expr_set
 @ Access the subevent index.
 <<Subevt expr: event expr: TBP>>=
   procedure :: has_event_index => event_expr_has_event_index
   procedure :: get_event_index => event_expr_get_event_index
 <<Subevt expr: procedures>>=
   function event_expr_has_event_index (expr) result (flag)
     class(event_expr_t), intent(in) :: expr
     logical :: flag
     flag = expr%has_index
   end function event_expr_has_event_index
 
   function event_expr_get_event_index (expr) result (index)
     class(event_expr_t), intent(in) :: expr
     integer :: index
     if (expr%has_index) then
        index = expr%index
     else
        index = 0
     end if
   end function event_expr_get_event_index
   
 @ %def event_expr_has_event_index
 @ %def event_expr_get_event_index
 @ Set/increment the subevent index.  Initialize it if necessary.
 <<Subevt expr: event expr: TBP>>=
   procedure :: set_event_index => event_expr_set_event_index
   procedure :: reset_event_index => event_expr_reset_event_index
   procedure :: increment_event_index => event_expr_increment_event_index
 <<Subevt expr: procedures>>=
   subroutine event_expr_set_event_index (expr, index)
     class(event_expr_t), intent(inout) :: expr
     integer, intent(in) :: index
     expr%index = index
     expr%has_index = .true.
   end subroutine event_expr_set_event_index
 
   subroutine event_expr_reset_event_index (expr)
     class(event_expr_t), intent(inout) :: expr
     expr%has_index = .false.
   end subroutine event_expr_reset_event_index
 
   subroutine event_expr_increment_event_index (expr, offset)
     class(event_expr_t), intent(inout) :: expr
     integer, intent(in), optional :: offset
     if (expr%has_index) then
        expr%index = expr%index + 1
     else if (present (offset)) then
        call expr%set_event_index (offset + 1)
     else
        call expr%set_event_index (1)
     end if
   end subroutine event_expr_increment_event_index
 
 @ %def event_expr_set_event_index
 @ %def event_expr_increment_event_index
 @ Fill the event expression: take the particle data and kinematics
 from a [[particle_set]] object.
 
 We allow the particle content to change for each event.  Therefore, we set the
 event variables each time.
 
 Also increment the event index; initialize it if necessary.
 <<Subevt expr: event expr: TBP>>=
   procedure :: fill_subevt => event_expr_fill_subevt
 <<Subevt expr: procedures>>=
   subroutine event_expr_fill_subevt (expr, particle_set)
     class(event_expr_t), intent(inout) :: expr
     type(particle_set_t), intent(in) :: particle_set
-    call particle_set%to_subevt (expr%subevt_t)
+    call particle_set%to_subevt (expr%subevt_t, expr%colorize_subevt)
     expr%sqrts_hat = subevt_get_sqrts_hat (expr%subevt_t)
     expr%n_in  = subevt_get_n_in  (expr%subevt_t)
     expr%n_out = subevt_get_n_out (expr%subevt_t)
     expr%n_tot = expr%n_in + expr%n_out
     expr%subevt_filled = .true.
   end subroutine event_expr_fill_subevt
 
 @ %def event_expr_fill_subevt
 @ Evaluate, if the event passes the selection.  For absent expressions we take
 default values.
 <<Subevt expr: event expr: TBP>>=
   procedure :: evaluate => event_expr_evaluate
 <<Subevt expr: procedures>>=
   subroutine event_expr_evaluate (expr, passed, reweight, analysis_flag)
     class(event_expr_t), intent(inout) :: expr
     logical, intent(out) :: passed
     real(default), intent(out) :: reweight
     logical, intent(out) :: analysis_flag
     call expr%base_evaluate (passed)
     if (passed) then
        if (expr%has_reweight) then
           call expr%reweight%evaluate ()
           if (expr%reweight%is_known ()) then
              reweight = expr%reweight%get_real ()
           else
              call msg_error ("Evaluate reweight expression: &
                   &result undefined")
              reweight = 0
           end if
        else
           reweight = 1
        end if
        if (expr%has_analysis) then
           call expr%analysis%evaluate ()
           if (expr%analysis%is_known ()) then
              analysis_flag = expr%analysis%get_log ()
           else
              call msg_error ("Evaluate analysis expression: &
                   &result undefined")
              analysis_flag = .false.
           end if
        else
           analysis_flag = .true.
        end if
     end if
   end subroutine event_expr_evaluate
 
 @ %def event_expr_evaluate
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Parton states}
 A [[parton_state_t]] object contains the effective kinematics and
 dynamics of an elementary partonic interaction, with or without the
 beam/structure function state included.  The type is abstract and has
 two distinct extensions.  The [[isolated_state_t]] extension describes
 the isolated elementary interaction where the [[int_eff]] subobject
 contains the complex transition amplitude, exclusive in all quantum
 numbers.  The particle content and kinematics describe the effective
 partonic state.  The [[connected_state_t]] extension contains the
 partonic [[subevt]] and the expressions for cuts and scales which use
 it.
 
 In the isolated state, the effective partonic interaction may either
 be identical to the hard interaction, in which case it is just a
 pointer to the latter.  Or it may involve a rearrangement of partons,
 in which case we allocate it explicitly and flag this by
 [[int_is_allocated]].
 
 The [[trace]] evaluator contains the absolute square of the effective
 transition amplitude matrix, summed over final states.  It is also summed over
 initial states, depending on the the beam setup allows.  The result is used for
 integration.
 
 The [[matrix]] evaluator is the counterpart of [[trace]] which is kept
 exclusive in all observable quantum numbers.  The [[flows]] evaluator is
 furthermore exclusive in colors, but neglecting all color interference.  The
 [[matrix]] and [[flows]] evaluators are filled only for sampling points that
 become part of physical events.
 
 Note: It would be natural to make the evaluators allocatable.
 However, this causes memory corruption in gfortran 4.6.3.  The extra
 [[has_XXX]] flags indicate whether evaluators are active, instead.
 
 This module contains no unit tests.  The tests are covered by the
 [[processes]] module below.
 <<[[parton_states.f90]]>>=
 <<File header>>
 module parton_states
 
 <<Use kinds>>
   use io_units
   use format_utils, only: write_separator
   use diagnostics
   use lorentz
   use subevents
   use variables
   use expr_base
   use model_data
   use flavors
   use helicities
   use colors
   use quantum_numbers
   use state_matrices
   use polarizations
   use interactions
   use evaluators
 
   use beams
   use sf_base
   use process_constants
   use prc_core
   use subevt_expr
 
 <<Standard module head>>
 
 <<Parton states: public>>
 
 <<Parton states: types>>
 
 contains
 
 <<Parton states: procedures>>
 
 end module parton_states
 @ %def parton_states
 @
 \subsection{Abstract base type}
 The common part are the evaluators, one for the trace (summed over all
 quantum numbers), one for the transition matrix (summed only over
 unobservable quantum numbers), and one for the flow distribution
 (transition matrix without interferences, exclusive in color flow).
 <<Parton states: types>>=
   type, abstract :: parton_state_t
      logical :: has_trace = .false.
      logical :: has_matrix = .false.
      logical :: has_flows = .false.
      type(evaluator_t) :: trace
      type(evaluator_t) :: matrix
      type(evaluator_t) :: flows
    contains
    <<Parton states: parton state: TBP>>
   end type parton_state_t
 
 @ %def parton_state_t
 @ The [[isolated_state_t]] extension contains the [[sf_chain_eff]] object
 and the (hard) effective interaction [[int_eff]], separately, both
 implemented as a pointer.  The evaluators (trace, matrix, flows) apply
 to the hard interaction only.
 
 If the effective interaction differs from the hard interaction, the
 pointer is allocated explicitly.  Analogously for [[sf_chain_eff]].
 <<Parton states: public>>=
   public :: isolated_state_t
 <<Parton states: types>>=
   type, extends (parton_state_t) :: isolated_state_t
      logical :: sf_chain_is_allocated = .false.
      type(sf_chain_instance_t), pointer :: sf_chain_eff => null ()
      logical :: int_is_allocated = .false.
      type(interaction_t), pointer :: int_eff => null ()
    contains
    <<Parton states: isolated state: TBP>>
   end type isolated_state_t
 
 @ %def isolated_state_t
 @ The [[connected_state_t]] extension contains all data that enable
 the evaluation of observables for the effective connected state.  The
 evaluators connect the (effective) structure-function chain and hard
 interaction that were kept separate in the [[isolated_state_t]].
 
 The [[flows_sf]] evaluator is an extended copy of the
 structure-function
 
 The [[expr]] subobject consists of the [[subevt]], a simple event record,
 expressions for cuts etc.\ which refer to this record, and a [[var_list]]
 which contains event-specific variables, linked to the process variable
 list.  Variables used within the expressions are looked up in [[var_list]].
 <<Parton states: public>>=
   public :: connected_state_t
 <<Parton states: types>>=
   type, extends (parton_state_t) :: connected_state_t
      type(state_flv_content_t) :: state_flv
      logical :: has_flows_sf = .false.
      type(evaluator_t) :: flows_sf
      logical :: has_expr = .false.
      type(parton_expr_t) :: expr
    contains
    <<Parton states: connected state: TBP>>
   end type connected_state_t
 
 @ %def connected_state_t
 @ Output: each evaluator is written only when it is active.  The
 [[sf_chain]] is only written if it is explicitly allocated.
 <<Parton states: parton state: TBP>>=
   procedure :: write => parton_state_write
 <<Parton states: procedures>>=
   subroutine parton_state_write (state, unit, testflag)
     class(parton_state_t), intent(in) :: state
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: testflag
     integer :: u
     u = given_output_unit (unit)
     select type (state)
     class is (isolated_state_t)
        if (state%sf_chain_is_allocated) then
           call write_separator (u)
           call state%sf_chain_eff%write (u)
        end if
        if (state%int_is_allocated) then
           call write_separator (u)
           write (u, "(1x,A)") &
                "Effective interaction:"
           call write_separator (u)
           call state%int_eff%basic_write (u, testflag = testflag)
        end if
     class is (connected_state_t)
        if (state%has_flows_sf) then
           call write_separator (u)
           write (u, "(1x,A)") &
                "Evaluator (extension of the beam evaluator &
                &with color contractions):"
           call write_separator (u)
           call state%flows_sf%write (u, testflag = testflag)
        end if
     end select
     if (state%has_trace) then
        call write_separator (u)
        write (u, "(1x,A)") &
             "Evaluator (trace of the squared transition matrix):"
        call write_separator (u)
        call state%trace%write (u, testflag = testflag)
     end if
     if (state%has_matrix) then
        call write_separator (u)
        write (u, "(1x,A)") &
             "Evaluator (squared transition matrix):"
        call write_separator (u)
        call state%matrix%write (u, testflag = testflag)
     end if
     if (state%has_flows) then
        call write_separator (u)
        write (u, "(1x,A)") &
             "Evaluator (squared color-flow matrix):"
        call write_separator (u)
        call state%flows%write (u, testflag = testflag)
     end if
     select type (state)
     class is (connected_state_t)
        if (state%has_expr) then
           call write_separator (u)
           call state%expr%write (u)
        end if
     end select
   end subroutine parton_state_write
 
 @ %def parton_state_write
 @ Finalize interaction and evaluators, but only if allocated.
 <<Parton states: parton state: TBP>>=
   procedure :: final => parton_state_final
 <<Parton states: procedures>>=
   subroutine parton_state_final (state)
     class(parton_state_t), intent(inout) :: state
     if (state%has_flows) then
        call state%flows%final ()
        state%has_flows = .false.
     end if
     if (state%has_matrix) then
        call state%matrix%final ()
        state%has_matrix = .false.
     end if
     if (state%has_trace) then
        call state%trace%final ()
        state%has_trace = .false.
     end if
     select type (state)
     class is (connected_state_t)
        if (state%has_flows_sf) then
           call state%flows_sf%final ()
           state%has_flows_sf = .false.
        end if
        call state%expr%final ()
     class is (isolated_state_t)
        if (state%int_is_allocated) then
           call state%int_eff%final ()
           deallocate (state%int_eff)
           state%int_is_allocated = .false.
        end if
        if (state%sf_chain_is_allocated) then
           call state%sf_chain_eff%final ()
        end if
     end select
   end subroutine parton_state_final
 
 @ %def parton_state_final
 @
 \subsection{Common Initialization}
 Initialize the isolated parton state.  In this version, the
 effective structure-function chain [[sf_chain_eff]] and the effective
 interaction [[int_eff]] both are trivial pointers to the seed
 structure-function chain and to the hard interaction, respectively.
 <<Parton states: isolated state: TBP>>=
   procedure :: init => isolated_state_init
 <<Parton states: procedures>>=
   subroutine isolated_state_init (state, sf_chain, int)
     class(isolated_state_t), intent(out) :: state
     type(sf_chain_instance_t), intent(in), target :: sf_chain
     type(interaction_t), intent(in), target :: int
     state%sf_chain_eff => sf_chain
     state%int_eff => int
   end subroutine isolated_state_init
 
 @ %def isolated_state_init
 @
 \subsection{Evaluator initialization: isolated state}
 Create an evaluator for the trace of the squared transition matrix.
 The trace goes over all outgoing quantum numbers.  Whether we trace
 over incoming quantum numbers other than color, depends on the given
 [[qn_mask_in]].
 
 There are two options: explicitly computing the color factor table
 ([[use_cf]] false; [[nc]] defined), or taking the color factor
 table from the hard matrix element data.
 <<Parton states: isolated state: TBP>>=
   procedure :: setup_square_trace => isolated_state_setup_square_trace
 <<Parton states: procedures>>=
   subroutine isolated_state_setup_square_trace (state, core, &
        qn_mask_in, col, keep_fs_flavor)
     class(isolated_state_t), intent(inout), target :: state
     class(prc_core_t), intent(in) :: core
     type(quantum_numbers_mask_t), intent(in), dimension(:) :: qn_mask_in
     !!! Actually need allocatable attribute here fore once because col might
     !!! enter the subroutine non-allocated.
     integer, intent(in), dimension(:), allocatable :: col
     logical, intent(in) :: keep_fs_flavor
     type(quantum_numbers_mask_t), dimension(:), allocatable :: qn_mask
     associate (data => core%data)
       allocate (qn_mask (data%n_in + data%n_out))
       qn_mask( : data%n_in) = &
               quantum_numbers_mask (.false., .true., .false.) &
               .or. qn_mask_in
       qn_mask(data%n_in + 1 : ) = &
               quantum_numbers_mask (.not. keep_fs_flavor, .true., .true.)
       if (core%use_color_factors) then
          call state%trace%init_square (state%int_eff, qn_mask, &
               col_flow_index = data%cf_index, &
               col_factor = data%color_factors, &
               col_index_hi = col, &
               nc = core%nc)
       else
          call state%trace%init_square (state%int_eff, qn_mask, nc = core%nc)
       end if
     end associate
     state%has_trace = .true.
   end subroutine isolated_state_setup_square_trace
 
 @ %def isolated_state_setup_square_trace
 @ Setup an identity-evaluator for the trace. This implies that [[me]]
 is considered to be a squared amplitude, as for example for BLHA matrix
 elements.
 <<Parton states: isolated state: TBP>>=
   procedure :: setup_identity_trace => isolated_state_setup_identity_trace
 <<Parton states: procedures>>=
   subroutine isolated_state_setup_identity_trace (state, core, qn_mask_in, &
       keep_fs_flavors, keep_colors)
      class(isolated_state_t), intent(inout), target :: state
      class(prc_core_t), intent(in) :: core
      type(quantum_numbers_mask_t), intent(in), dimension(:) :: qn_mask_in
      logical, intent(in), optional :: keep_fs_flavors, keep_colors
      type(quantum_numbers_mask_t), dimension(:), allocatable :: qn_mask
      logical :: fs_flv_flag, col_flag
      fs_flv_flag = .true.; col_flag = .true.
      if (present(keep_fs_flavors)) fs_flv_flag = .not. keep_fs_flavors
      if (present(keep_colors)) col_flag = .not. keep_colors
      associate (data => core%data)
         allocate (qn_mask (data%n_in + data%n_out))
         qn_mask( : data%n_in) = &
            quantum_numbers_mask (.false., col_flag, .false.) .or. qn_mask_in
         qn_mask(data%n_in + 1 : ) = &
            quantum_numbers_mask (fs_flv_flag, col_flag, .true.)
      end associate
      call state%int_eff%set_mask (qn_mask)
      call state%trace%init_identity (state%int_eff)
      state%has_trace = .true.
   end subroutine isolated_state_setup_identity_trace
 
 @ %def isolated_state_setup_identity_trace
 @ Setup the evaluator for the transition matrix, exclusive in
 helicities where this is requested.
 
 For all unstable final-state particles we keep polarization according to the
 applicable decay options.  If the process is a decay itself, this applies also
 to the initial state.
 
 For all polarized final-state particles, we keep polarization including
 off-diagonal entries.  We drop helicity completely for unpolarized final-state
 particles.
 
 For the initial state, if the particle has not been handled yet, we
 apply the provided [[qn_mask_in]] which communicates the beam properties.
 <<Parton states: isolated state: TBP>>=
   procedure :: setup_square_matrix => isolated_state_setup_square_matrix
 <<Parton states: procedures>>=
   subroutine isolated_state_setup_square_matrix &
        (state, core, model, qn_mask_in, col)
     class(isolated_state_t), intent(inout), target :: state
     class(prc_core_t), intent(in) :: core
     class(model_data_t), intent(in), target :: model
     type(quantum_numbers_mask_t), dimension(:), intent(in) :: qn_mask_in
     integer, dimension(:), intent(in) :: col
     type(quantum_numbers_mask_t), dimension(:), allocatable :: qn_mask
     type(flavor_t), dimension(:), allocatable :: flv
     integer :: i
     logical :: helmask, helmask_hd
     associate (data => core%data)
       allocate (qn_mask (data%n_in + data%n_out))
       allocate (flv (data%n_flv))
       do i = 1, data%n_in + data%n_out
          call flv%init (data%flv_state(i,:), model)
          if ((data%n_in == 1 .or. i > data%n_in) &
               .and. any (.not. flv%is_stable ())) then
             helmask = all (flv%decays_isotropically ())
             helmask_hd = all (flv%decays_diagonal ())
             qn_mask(i) = quantum_numbers_mask (.false., .true., helmask, &
                  mask_hd = helmask_hd)
          else if (i > data%n_in) then
             helmask = all (.not. flv%is_polarized ())
             qn_mask(i) = quantum_numbers_mask (.false., .true., helmask)
          else
             qn_mask(i) = quantum_numbers_mask (.false., .true., .false.) &
               .or. qn_mask_in(i)
          end if
       end do
       if (core%use_color_factors) then
          call state%matrix%init_square (state%int_eff, qn_mask, &
               col_flow_index = data%cf_index, &
               col_factor = data%color_factors, &
               col_index_hi = col, &
               nc = core%nc)
       else
          call state%matrix%init_square (state%int_eff, &
               qn_mask, &
               nc = core%nc)
       end if
     end associate
     state%has_matrix = .true.
   end subroutine isolated_state_setup_square_matrix
 
 @ %def isolated_state_setup_square_matrix
 @ This procedure initializes the evaluator that computes the
 contributions to color flows, neglecting color interference.
 The incoming-particle mask can be used to sum over incoming flavor.
 
 Helicity handling: see above.
 <<Parton states: isolated state: TBP>>=
   procedure :: setup_square_flows => isolated_state_setup_square_flows
 <<Parton states: procedures>>=
   subroutine isolated_state_setup_square_flows (state, core, model, qn_mask_in)
     class(isolated_state_t), intent(inout), target :: state
     class(prc_core_t), intent(in) :: core
     class(model_data_t), intent(in), target :: model
     type(quantum_numbers_mask_t), dimension(:), intent(in) :: qn_mask_in
     type(quantum_numbers_mask_t), dimension(:), allocatable :: qn_mask
     type(flavor_t), dimension(:), allocatable :: flv
     integer :: i
     logical :: helmask, helmask_hd
     associate (data => core%data)
       allocate (qn_mask (data%n_in + data%n_out))
       allocate (flv (data%n_flv))
       do i = 1, data%n_in + data%n_out
          call flv%init (data%flv_state(i,:), model)
          if ((data%n_in == 1 .or. i > data%n_in) &
               .and. any (.not. flv%is_stable ())) then
             helmask = all (flv%decays_isotropically ())
             helmask_hd = all (flv%decays_diagonal ())
             qn_mask(i) = quantum_numbers_mask (.false., .false., helmask, &
                  mask_hd = helmask_hd)
          else if (i > data%n_in) then
             helmask = all (.not. flv%is_polarized ())
             qn_mask(i) = quantum_numbers_mask (.false., .false., helmask)
          else
             qn_mask(i) = quantum_numbers_mask (.false., .false., .false.) &
               .or. qn_mask_in(i)
          end if
       end do
       call state%flows%init_square (state%int_eff, qn_mask, &
            expand_color_flows = .true.)
     end associate
     state%has_flows = .true.
   end subroutine isolated_state_setup_square_flows
 
 @ %def isolated_state_setup_square_flows
 @
 \subsection{Evaluator initialization: connected state}
 Setup a trace evaluator as a product of two evaluators (incoming state,
 effective interaction).  In the result, all quantum numbers are summed over.
 
 If the optional [[int]] interaction is provided, use this for the
 first factor in the convolution.  Otherwise, use the final interaction
 of the stored [[sf_chain]].
 
 The [[resonant]] flag applies if we want to construct
 a decay chain.  The resonance property can propagate to the final
 event output.
 <<Parton states: connected state: TBP>>=
   procedure :: setup_connected_trace => connected_state_setup_connected_trace
 <<Parton states: procedures>>=
   subroutine connected_state_setup_connected_trace &
        (state, isolated, int, resonant, undo_helicities, &
         keep_fs_flavors, extended_sf)
     class(connected_state_t), intent(inout), target :: state
     type(isolated_state_t), intent(in), target :: isolated
     type(interaction_t), intent(in), optional, target :: int
     logical, intent(in), optional :: resonant
     logical, intent(in), optional :: undo_helicities
     logical, intent(in), optional :: keep_fs_flavors
     logical, intent(in), optional :: extended_sf
     type(quantum_numbers_mask_t) :: mask
     type(interaction_t), pointer :: src_int, beam_int
     logical :: reduce, fs_flv_flag
     call msg_debug (D_PROCESS_INTEGRATION, &
          "connected_state_setup_connected_trace")
     reduce = .false.; fs_flv_flag = .true.
     if (present (undo_helicities)) reduce = undo_helicities
     if (present (keep_fs_flavors)) fs_flv_flag = .not. keep_fs_flavors
     mask = quantum_numbers_mask (fs_flv_flag, .true., .true.)
     if (present (int)) then
        src_int => int
     else
        src_int => isolated%sf_chain_eff%get_out_int_ptr ()
     end if
 
     if (debug2_active (D_PROCESS_INTEGRATION)) then
        call src_int%basic_write ()
     end if
 
     call state%trace%init_product (src_int, isolated%trace, &
          qn_mask_conn = mask, &
          qn_mask_rest = mask, &
          connections_are_resonant = resonant, &
          ignore_sub = extended_sf)
 
     if (reduce) then
        beam_int => isolated%sf_chain_eff%get_beam_int_ptr ()
        call undo_qn_hel (beam_int, mask, beam_int%get_n_tot ())
        call beam_int%set_matrix_element (cmplx (1, 0, default))
     end if
 
     state%has_trace = .true.
   contains
     subroutine undo_qn_hel (int_in, mask, n_tot)
       type(interaction_t), intent(inout) :: int_in
       type(quantum_numbers_mask_t), intent(in) :: mask
       integer, intent(in) :: n_tot
       type(quantum_numbers_mask_t), dimension(n_tot) :: mask_in
       mask_in = mask
       call int_in%set_mask (mask_in)
     end subroutine undo_qn_hel
   end subroutine connected_state_setup_connected_trace
 
 @ %def connected_state_setup_connected_trace
 @ Setup a matrix evaluator as a product of two evaluators (incoming
 state, effective interation).  In the intermediate state, color and
 helicity is summed over.  In the final state, we keep the quantum
 numbers which are present in the original evaluators.
 <<Parton states: connected state: TBP>>=
   procedure :: setup_connected_matrix => connected_state_setup_connected_matrix
 <<Parton states: procedures>>=
   subroutine connected_state_setup_connected_matrix &
        (state, isolated, int, resonant, qn_filter_conn)
     class(connected_state_t), intent(inout), target :: state
     type(isolated_state_t), intent(in), target :: isolated
     type(interaction_t), intent(in), optional, target :: int
     logical, intent(in), optional :: resonant
     type(quantum_numbers_t), intent(in), optional :: qn_filter_conn
     type(quantum_numbers_mask_t) :: mask
     type(interaction_t), pointer :: src_int
     mask = quantum_numbers_mask (.false., .true., .true.)
     if (present (int)) then
        src_int => int
     else
        src_int => isolated%sf_chain_eff%get_out_int_ptr ()
     end if
     call state%matrix%init_product &
          (src_int, isolated%matrix, mask, &
           qn_filter_conn = qn_filter_conn, &
           connections_are_resonant = resonant)
     state%has_matrix = .true.
   end subroutine connected_state_setup_connected_matrix
 
 @ %def connected_state_setup_connected_matrix
 @ Setup a matrix evaluator as a product of two evaluators (incoming
 state, effective interation).  In the intermediate state, only
 helicity is summed over.  In the final state, we keep the quantum
 numbers which are present in the original evaluators.
 
 
 If the optional [[int]] interaction is provided, use this for the
 first factor in the convolution.  Otherwise, use the final interaction
 of the stored [[sf_chain]], after creating an intermediate interaction
 that includes a correlated color state.  We assume that for a
 caller-provided [[int]], this is not necessary.
 <<Parton states: connected state: TBP>>=
   procedure :: setup_connected_flows => connected_state_setup_connected_flows
 <<Parton states: procedures>>=
   subroutine connected_state_setup_connected_flows &
        (state, isolated, int, resonant, qn_filter_conn)
     class(connected_state_t), intent(inout), target :: state
     type(isolated_state_t), intent(in), target :: isolated
     type(interaction_t), intent(in), optional, target :: int
     logical, intent(in), optional :: resonant
     type(quantum_numbers_t), intent(in), optional :: qn_filter_conn
     type(quantum_numbers_mask_t) :: mask
     type(interaction_t), pointer :: src_int
     mask = quantum_numbers_mask (.false., .false., .true.)
     if (present (int)) then
        src_int => int
     else
        src_int => isolated%sf_chain_eff%get_out_int_ptr ()
        call state%flows_sf%init_color_contractions (src_int)
        state%has_flows_sf = .true.
        src_int => state%flows_sf%interaction_t
     end if
     call state%flows%init_product (src_int, isolated%flows, mask, &
          qn_filter_conn = qn_filter_conn, &
          connections_are_resonant = resonant)
     state%has_flows = .true.
   end subroutine connected_state_setup_connected_flows
 
 @ %def connected_state_setup_connected_flows
 @ Determine and store the flavor content for the connected state.
 This queries the [[matrix]] evaluator component, which should hold the
 requested flavor information.
 <<Parton states: connected state: TBP>>=
   procedure :: setup_state_flv => connected_state_setup_state_flv
 <<Parton states: procedures>>=
   subroutine connected_state_setup_state_flv (state, n_out_hard)
     class(connected_state_t), intent(inout), target :: state
     integer, intent(in) :: n_out_hard
     call interaction_get_flv_content &
          (state%matrix%interaction_t, state%state_flv, n_out_hard)
   end subroutine connected_state_setup_state_flv
 
 @ %def connected_state_setup_state_flv
 @ Return the current flavor state object.
 <<Parton states: connected state: TBP>>=
   procedure :: get_state_flv => connected_state_get_state_flv
 <<Parton states: procedures>>=
   function connected_state_get_state_flv (state) result (state_flv)
     class(connected_state_t), intent(in) :: state
     type(state_flv_content_t) :: state_flv
     state_flv = state%state_flv
   end function connected_state_get_state_flv
 
 @ %def connected_state_get_state_flv
 @
 \subsection{Cuts and expressions}
 Set up the [[subevt]] that corresponds to the connected interaction.
 The index arrays refer to the interaction.
 
 We assign the particles as follows: the beam particles are the first
 two (decay process: one) entries in the trace evaluator.  The incoming
 partons are identified by their link to the outgoing partons of the
 structure-function chain.  The outgoing partons are those of the trace
 evaluator, which include radiated partons during the
 structure-function chain.
 <<Parton states: connected state: TBP>>=
   procedure :: setup_subevt => connected_state_setup_subevt
 <<Parton states: procedures>>=
   subroutine connected_state_setup_subevt (state, sf_chain, f_beam, f_in, f_out)
     class(connected_state_t), intent(inout), target :: state
     type(sf_chain_instance_t), intent(in), target :: sf_chain
     type(flavor_t), dimension(:), intent(in) :: f_beam, f_in, f_out
     integer :: n_beam, n_in, n_out, n_vir, n_tot, i, j
     integer, dimension(:), allocatable :: i_beam, i_in, i_out
     integer :: sf_out_i
     type(interaction_t), pointer :: sf_int
     sf_int => sf_chain%get_out_int_ptr ()
     n_beam = size (f_beam)
     n_in = size (f_in)
     n_out = size (f_out)
     n_vir = state%trace%get_n_vir ()
     n_tot = state%trace%get_n_tot ()
     allocate (i_beam (n_beam), i_in (n_in), i_out (n_out))
     i_beam = [(i, i = 1, n_beam)]
     do j = 1, n_in
        sf_out_i = sf_chain%get_out_i (j)
        i_in(j) = interaction_find_link &
             (state%trace%interaction_t, sf_int, sf_out_i)
     end do
     i_out = [(i, i = n_vir + 1, n_tot)]
     call state%expr%setup_subevt (state%trace%interaction_t, &
          i_beam, i_in, i_out, f_beam, f_in, f_out)
     state%has_expr = .true.
   end subroutine connected_state_setup_subevt
 
 @ %def connected_state_setup_subevt
 @ Initialize the variable list specific for this state/term.  We insert event
 variables ([[sqrts_hat]]) and link the process variable list.  The variable
 list acquires pointers to subobjects of [[state]], which must therefore have a
 [[target]] attribute.
 <<Parton states: connected state: TBP>>=
   procedure :: setup_var_list => connected_state_setup_var_list
 <<Parton states: procedures>>=
   subroutine connected_state_setup_var_list (state, process_var_list, beam_data)
     class(connected_state_t), intent(inout), target :: state
     type(var_list_t), intent(in), target :: process_var_list
     type(beam_data_t), intent(in) :: beam_data
     call state%expr%setup_vars (beam_data%get_sqrts ())
     call state%expr%link_var_list (process_var_list)
   end subroutine connected_state_setup_var_list
 
 @ %def connected_state_setup_var_list
 @ Allocate the cut expression etc.
 <<Parton states: connected state: TBP>>=
   procedure :: setup_cuts => connected_state_setup_cuts
   procedure :: setup_scale => connected_state_setup_scale
   procedure :: setup_fac_scale => connected_state_setup_fac_scale
   procedure :: setup_ren_scale => connected_state_setup_ren_scale
   procedure :: setup_weight => connected_state_setup_weight
 <<Parton states: procedures>>=
   subroutine connected_state_setup_cuts (state, ef_cuts)
     class(connected_state_t), intent(inout), target :: state
     class(expr_factory_t), intent(in) :: ef_cuts
     call state%expr%setup_selection (ef_cuts)
   end subroutine connected_state_setup_cuts
 
   subroutine connected_state_setup_scale (state, ef_scale)
     class(connected_state_t), intent(inout), target :: state
     class(expr_factory_t), intent(in) :: ef_scale
     call state%expr%setup_scale (ef_scale)
   end subroutine connected_state_setup_scale
 
   subroutine connected_state_setup_fac_scale (state, ef_fac_scale)
     class(connected_state_t), intent(inout), target :: state
     class(expr_factory_t), intent(in) :: ef_fac_scale
     call state%expr%setup_fac_scale (ef_fac_scale)
   end subroutine connected_state_setup_fac_scale
 
   subroutine connected_state_setup_ren_scale (state, ef_ren_scale)
     class(connected_state_t), intent(inout), target :: state
     class(expr_factory_t), intent(in) :: ef_ren_scale
     call state%expr%setup_ren_scale (ef_ren_scale)
   end subroutine connected_state_setup_ren_scale
 
   subroutine connected_state_setup_weight (state, ef_weight)
     class(connected_state_t), intent(inout), target :: state
     class(expr_factory_t), intent(in) :: ef_weight
     call state%expr%setup_weight (ef_weight)
   end subroutine connected_state_setup_weight
 
 @ %def connected_state_setup_expressions
 @ Reset the expression object: invalidate the subevt.
 <<Parton states: connected state: TBP>>=
   procedure :: reset_expressions => connected_state_reset_expressions
 <<Parton states: procedures>>=
   subroutine connected_state_reset_expressions (state)
     class(connected_state_t), intent(inout) :: state
     if (state%has_expr)  call state%expr%reset_contents ()
   end subroutine connected_state_reset_expressions
 
 @ %def connected_state_reset_expressions
 @
 \subsection{Evaluation}
 Transfer momenta to the trace evaluator and fill the [[subevt]] with
 this effective kinematics, if applicable.
 
 Note: we may want to apply a boost for the [[subevt]].
 <<Parton states: parton state: TBP>>=
   procedure :: receive_kinematics => parton_state_receive_kinematics
 <<Parton states: procedures>>=
   subroutine parton_state_receive_kinematics (state)
     class(parton_state_t), intent(inout), target :: state
     if (state%has_trace) then
        call state%trace%receive_momenta ()
        select type (state)
        class is (connected_state_t)
           if (state%has_expr) then
              call state%expr%fill_subevt (state%trace%interaction_t)
           end if
        end select
     end if
   end subroutine parton_state_receive_kinematics
 
 @ %def parton_state_receive_kinematics
 @ Recover kinematics: We assume that the trace evaluator is filled
 with momenta.  Send those momenta back to the sources, then fill the
 variables and subevent as above.
 
 The incoming momenta of the connected state are not connected to the
 isolated state but to the beam interaction.  Therefore, the incoming
 momenta within the isolated state do not become defined, yet.
 Instead, we reconstruct the beam (and ISR) momentum configuration.
 <<Parton states: parton state: TBP>>=
   procedure :: send_kinematics => parton_state_send_kinematics
 <<Parton states: procedures>>=
   subroutine parton_state_send_kinematics (state)
     class(parton_state_t), intent(inout), target :: state
     if (state%has_trace) then
        call interaction_send_momenta (state%trace%interaction_t)
        select type (state)
        class is (connected_state_t)
           call state%expr%fill_subevt (state%trace%interaction_t)
        end select
     end if
   end subroutine parton_state_send_kinematics
 
 @ %def parton_state_send_kinematics
 @ Evaluate the expressions.  The routine evaluates first the cut expression.
 If the event passes, it evaluates the other expressions.  Where no expressions
 are defined, default values are inserted.
 <<Parton states: connected state: TBP>>=
   procedure :: evaluate_expressions => connected_state_evaluate_expressions
 <<Parton states: procedures>>=
   subroutine connected_state_evaluate_expressions (state, passed, &
        scale, fac_scale, ren_scale, weight, scale_forced, force_evaluation)
     class(connected_state_t), intent(inout) :: state
     logical, intent(out) :: passed
     real(default), intent(out) :: scale, fac_scale, ren_scale, weight
     real(default), intent(in), allocatable, optional :: scale_forced
     logical, intent(in), optional :: force_evaluation
     if (state%has_expr) then
        call state%expr%evaluate (passed, scale, fac_scale, ren_scale, weight, &
             scale_forced, force_evaluation)
     end if
   end subroutine connected_state_evaluate_expressions
 
 @ %def connected_state_evaluate_expressions
 @ Evaluate the structure-function chain, if it is allocated
 explicitly.  The argument is the factorization scale.
 
 If the chain is merely a pointer, the chain should already be
 evaluated at this point.
 <<Parton states: isolated state: TBP>>=
   procedure :: evaluate_sf_chain => isolated_state_evaluate_sf_chain
 <<Parton states: procedures>>=
   subroutine isolated_state_evaluate_sf_chain (state, fac_scale)
     class(isolated_state_t), intent(inout) :: state
     real(default), intent(in) :: fac_scale
     if (state%sf_chain_is_allocated)  call state%sf_chain_eff%evaluate (fac_scale)
   end subroutine isolated_state_evaluate_sf_chain
 
 @ %def isolated_state_evaluate_sf_chain
 @ Evaluate the trace.
 <<Parton states: parton state: TBP>>=
   procedure :: evaluate_trace => parton_state_evaluate_trace
 <<Parton states: procedures>>=
   subroutine parton_state_evaluate_trace (state)
     class(parton_state_t), intent(inout) :: state
     if (state%has_trace) call state%trace%evaluate ()
   end subroutine parton_state_evaluate_trace
 
 @ %def parton_state_evaluate_trace
 <<Parton states: parton state: TBP>>=
   procedure :: evaluate_matrix => parton_state_evaluate_matrix
 <<Parton states: procedures>>=
   subroutine parton_state_evaluate_matrix (state)
     class(parton_state_t), intent(inout) :: state
     if (state%has_matrix) call state%matrix%evaluate ()
   end subroutine parton_state_evaluate_matrix
 
 @ %def parton_state_evaluate_matrix
 @ Evaluate the extra evaluators that we need for physical events.
 <<Parton states: parton state: TBP>>=
   procedure :: evaluate_event_data => parton_state_evaluate_event_data
 <<Parton states: procedures>>=
   subroutine parton_state_evaluate_event_data (state, only_momenta)
     class(parton_state_t), intent(inout) :: state
     logical, intent(in), optional :: only_momenta
     logical :: only_mom
     only_mom = .false.; if (present (only_momenta)) only_mom = only_momenta
     select type (state)
     type is (connected_state_t)
        if (state%has_flows_sf) then
           call state%flows_sf%receive_momenta ()
           if (.not. only_mom) call state%flows_sf%evaluate ()
        end if
     end select
     if (state%has_matrix) then
        call state%matrix%receive_momenta ()
        if (.not. only_mom) call state%matrix%evaluate ()
     end if
     if (state%has_flows) then
        call state%flows%receive_momenta ()
        if (.not. only_mom) call state%flows%evaluate ()
     end if
   end subroutine parton_state_evaluate_event_data
 
 @ %def parton_state_evaluate_event_data
 @ Normalize the helicity density matrix by its trace, i.e., factor out
 the trace and put it into an overall normalization factor.  The trace
 and flow evaluators are unchanged.
 <<Parton states: parton state: TBP>>=
   procedure :: normalize_matrix_by_trace => &
        parton_state_normalize_matrix_by_trace
 <<Parton states: procedures>>=
   subroutine parton_state_normalize_matrix_by_trace (state)
     class(parton_state_t), intent(inout) :: state
     if (state%has_matrix) call state%matrix%normalize_by_trace ()
   end subroutine parton_state_normalize_matrix_by_trace
 
 @ %def parton_state_normalize_matrix_by_trace
 @
 \subsection{Accessing the state}
 Three functions return a pointer to the event-relevant interactions.
 <<Parton states: parton state: TBP>>=
   procedure :: get_trace_int_ptr => parton_state_get_trace_int_ptr
   procedure :: get_matrix_int_ptr => parton_state_get_matrix_int_ptr
   procedure :: get_flows_int_ptr => parton_state_get_flows_int_ptr
 <<Parton states: procedures>>=
   function parton_state_get_trace_int_ptr (state) result (ptr)
     class(parton_state_t), intent(in), target :: state
     type(interaction_t), pointer :: ptr
     if (state%has_trace) then
        ptr => state%trace%interaction_t
     else
        ptr => null ()
     end if
   end function parton_state_get_trace_int_ptr
 
   function parton_state_get_matrix_int_ptr (state) result (ptr)
     class(parton_state_t), intent(in), target :: state
     type(interaction_t), pointer :: ptr
     if (state%has_matrix) then
        ptr => state%matrix%interaction_t
     else
        ptr => null ()
     end if
   end function parton_state_get_matrix_int_ptr
 
   function parton_state_get_flows_int_ptr (state) result (ptr)
     class(parton_state_t), intent(in), target :: state
     type(interaction_t), pointer :: ptr
     if (state%has_flows) then
        ptr => state%flows%interaction_t
     else
        ptr => null ()
     end if
   end function parton_state_get_flows_int_ptr
 
 @ %def parton_state_get_trace_int_ptr
 @ %def parton_state_get_matrix_int_ptr
 @ %def parton_state_get_flows_int_ptr
 @ Return the indices of the beam particles and the outgoing particles within
 the trace (and thus, matrix and flows) evaluator, respectively.
 <<Parton states: connected state: TBP>>=
   procedure :: get_beam_index => connected_state_get_beam_index
   procedure :: get_in_index => connected_state_get_in_index
 <<Parton states: procedures>>=
   subroutine connected_state_get_beam_index (state, i_beam)
     class(connected_state_t), intent(in) :: state
     integer, dimension(:), intent(out) :: i_beam
     call state%expr%get_beam_index (i_beam)
   end subroutine connected_state_get_beam_index
 
   subroutine connected_state_get_in_index (state, i_in)
     class(connected_state_t), intent(in) :: state
     integer, dimension(:), intent(out) :: i_in
     call state%expr%get_in_index (i_in)
   end subroutine connected_state_get_in_index
 
 @ %def connected_state_get_beam_index
 @ %def connected_state_get_in_index
 @
 <<Parton states: public>>=
   public :: refill_evaluator
 <<Parton states: procedures>>=
   subroutine refill_evaluator (sqme, qn, flv_index, evaluator)
     complex(default), intent(in), dimension(:) :: sqme
     type(quantum_numbers_t), intent(in), dimension(:,:) :: qn
     integer, intent(in), dimension(:), optional :: flv_index
     type(evaluator_t), intent(inout) :: evaluator
     integer :: i, i_flv
     do i = 1, size (sqme)
        if (present (flv_index)) then
           i_flv = flv_index(i)
        else
           i_flv = i
        end if
        call evaluator%add_to_matrix_element (qn(:,i_flv), sqme(i), &
             match_only_flavor = .true.)
     end do
   end subroutine refill_evaluator
 
 @ %def refill_evaluator
 @ Return the number of outgoing (hard) particles for the state.
 <<Parton states: parton state: TBP>>=
   procedure :: get_n_out => parton_state_get_n_out
 <<Parton states: procedures>>=
   function parton_state_get_n_out (state) result (n)
     class(parton_state_t), intent(in), target :: state
     integer :: n
     n = state%trace%get_n_out ()
   end function parton_state_get_n_out
 
 @ %def parton_state_get_n_out
 @
 \subsection{Unit tests}
 <<[[parton_states_ut.f90]]>>=
 <<File header>>
 
 module parton_states_ut
   use unit_tests
   use parton_states_uti
 
 <<Standard module head>>
 
 <<Parton states: public test>>
 
 contains
 
 <<Parton states: test driver>>
 
 end module parton_states_ut
 @ %def parton_states_ut
 <<[[parton_states_uti.f90]]>>=
 <<File header>>
 
 module parton_states_uti
 
 <<Use kinds>>
 <<Use strings>>
   use constants, only: zero
   use numeric_utils
   use flavors
   use colors
   use helicities
   use quantum_numbers
   use sf_base, only: sf_chain_instance_t
   use state_matrices, only: state_matrix_t
   use prc_template_me, only: prc_template_me_t
   use interactions, only: interaction_t
   use models, only: model_t, create_test_model
   use parton_states
 
 <<Standard module head>>
 
 <<Parton states: test declarations>>
 
 contains
 
 <<Parton states: tests>>
 
 end module parton_states_uti
 @ %def parton_states_uti
 @
 <<Parton states: public test>>=
   public :: parton_states_test
 <<Parton states: test driver>>=
   subroutine parton_states_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Parton states: execute tests>>
   end subroutine parton_states_test
 
 @ %def parton_states_test
 @
 \subsubsection{Test a simple isolated state}
 <<Parton states: execute tests>>=
   call test (parton_states_1, "parton_states_1", &
        "Create a 2 -> 2 isolated state and compute trace", &
        u, results)
 <<Parton states: test declarations>>=
   public :: parton_states_1
 <<Parton states: tests>>=
   subroutine parton_states_1 (u)
     integer, intent(in) :: u
     type(state_matrix_t), allocatable :: state
     type(flavor_t), dimension(2) :: flv_in
     type(flavor_t), dimension(2) :: flv_out1, flv_out2
     type(flavor_t), dimension(4) :: flv_tot
     type(helicity_t), dimension(4) :: hel
     type(color_t), dimension(4) :: col
     integer :: h1, h2, h3, h4
     integer :: f
     integer :: i
     type(quantum_numbers_t), dimension(4) :: qn
     type(prc_template_me_t) :: core
     type(sf_chain_instance_t), target :: sf_chain
     type(interaction_t), target :: int
     type(isolated_state_t) :: isolated_state
     integer :: n_states = 0
     integer, dimension(:), allocatable :: col_flow_index
     type(quantum_numbers_mask_t), dimension(2) :: qn_mask
     integer, dimension(8) :: i_allowed_states
     complex(default), dimension(8) :: me
     complex(default) :: me_check_tot, me_check_1, me_check_2, me2
     logical :: tmp1, tmp2
     type(model_t), pointer :: test_model => null ()
 
     write (u, "(A)") "* Test output: parton_states_1"
     write (u, "(A)") "* Purpose: Test the standard parton states"
     write (u, "(A)")
 
     call flv_in%init ([11, -11])
     call flv_out1%init ([1, -1])
     call flv_out2%init ([2, -2])
 
     write (u, "(A)") "* Using incoming flavors: "
     call flavor_write_array (flv_in, u)
     write (u, "(A)") "* Two outgoing flavor structures: "
     call flavor_write_array (flv_out1, u)
     call flavor_write_array (flv_out2, u)
 
 
     write (u, "(A)") "* Initialize state matrix"
     allocate (state)
     call state%init ()
 
     write (u, "(A)") "* Fill state matrix"
     call col(3)%init ([1])
     call col(4)%init ([-1])
     do f = 1, 2
        do h1 = -1, 1, 2
           do h2 = -1, 1, 2
              do h3 = -1, 1, 2
                 do h4 = -1, 1, 2
                    n_states = n_states + 1
                    call hel%init ([h1, h2, h3, h4], [h1, h2, h3, h4])
                    if (f == 1) then
                       flv_tot = [flv_in, flv_out1]
                    else
                       flv_tot = [flv_in, flv_out2]
                    end if
                    call qn%init (flv_tot, col, hel)
                    call state%add_state (qn)
                 end do
              end do
           end do
        end do
     end do
 
     !!! Two flavors, one color flow, 2 x 2 x 2 x 2 helicity configurations
     !!! -> 32 states.
     write (u, "(A)")
     write (u, "(A,I2)") "* Generated number of states: ", n_states
 
     call state%freeze ()
 
     !!! Indices of the helicity configurations which are non-zero
     i_allowed_states = [6, 7, 10, 11, 22, 23, 26, 27]
     me = [cmplx (-1.89448E-5_default,  9.94456E-7_default, default), &
           cmplx (-8.37887E-2_default,  4.30842E-3_default, default), &
           cmplx (-1.99997E-1_default, -1.01985E-2_default, default), &
           cmplx ( 1.79717E-5_default,  9.27038E-7_default, default), &
           cmplx (-1.74859E-5_default,  8.78819E-7_default, default), &
           cmplx ( 1.67577E-1_default, -8.61683E-3_default, default), &
           cmplx ( 2.41331E-1_default,  1.23306E-2_default, default), &
           cmplx (-3.59435E-5_default, -1.85407E-6_default, default)]
     me_check_tot = cmplx (zero, zero, default)
     me_check_1 = cmplx (zero, zero, default)
     me_check_2 = cmplx (zero, zero, default)
     do i = 1, 8
        me2 = me(i) * conjg (me(i))
        me_check_tot = me_check_tot + me2
        if (i < 5) then
           me_check_1 = me_check_1 + me2
        else
           me_check_2 = me_check_2 + me2
        end if
        call state%set_matrix_element (i_allowed_states(i), me(i))
     end do
 
     !!! Don't forget the color factor
     me_check_tot = 3._default * me_check_tot
     me_check_1 = 3._default * me_check_1
     me_check_2 = 3._default * me_check_2
     write (u, "(A)")
 
     write (u, "(A)") "* Setup interaction"
     call int%basic_init (2, 0, 2, set_relations = .true.)
     call int%set_state_matrix (state)
 
     core%data%n_in = 2; core%data%n_out = 2
     core%data%n_flv = 2
     allocate (core%data%flv_state (4, 2))
     core%data%flv_state (1, :) = [11, 11]
     core%data%flv_state (2, :) = [-11, -11]
     core%data%flv_state (3, :) = [1, 2]
     core%data%flv_state (4, :) = [-1, -2]
     core%use_color_factors = .false.
     core%nc = 3
 
     write (u, "(A)") "* Init isolated state"
     call isolated_state%init (sf_chain, int)
     !!! There is only one color flow.
     allocate (col_flow_index (n_states)); col_flow_index = 1
     call qn_mask%init (.false., .false., .true., mask_cg = .false.)
     write (u, "(A)") "* Give a trace to the isolated state"
     call isolated_state%setup_square_trace (core, qn_mask, col_flow_index, .false.)
     call isolated_state%evaluate_trace ()
     write (u, "(A)")
     write (u, "(A)", advance = "no") "* Squared matrix element correct: "
     write (u, "(L1)") nearly_equal (me_check_tot, &
        isolated_state%trace%get_matrix_element (1), rel_smallness = 0.00001_default)
 
 
     write (u, "(A)") "* Give a matrix to the isolated state"
     call create_test_model (var_str ("SM"), test_model)
     call isolated_state%setup_square_matrix (core, test_model, qn_mask, col_flow_index)
     call isolated_state%evaluate_matrix ()
 
     write (u, "(A)") "* Sub-matrixelements correct: "
     tmp1 = nearly_equal (me_check_1, &
        isolated_state%matrix%get_matrix_element (1), rel_smallness = 0.00001_default)
     tmp2 = nearly_equal (me_check_2, &
        isolated_state%matrix%get_matrix_element (2), rel_smallness = 0.00001_default)
     write (u, "(A,L1,A,L1)") "* 1: ", tmp1, ", 2: ", tmp2
 
     write (u, "(A)") "* Test output end: parton_states_1"
   end subroutine parton_states_1
 
 @ %def parton_states_1
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Process component management}
 This module contains tools for managing and combining process
 components and matrix-element code and values, acting at a level below
 the actual process definition.
 
 \subsection{Abstract base type}
 The types introduced here are abstract base types.
 <<[[pcm_base.f90]]>>=
 <<File header>>
 
 module pcm_base
 
   use diagnostics
 
   use prc_core_def
   use prc_core
 
 <<Standard module head>>
 
 <<PCM base: public>>
 
 <<PCM base: types>>
 
 <<PCM base: interfaces>>
 
 contains
 
 <<PCM base: procedures>>
 
 end module pcm_base
 @ %def pcm_base
 @ This object may hold process and method-specific data, and it should
 allocate the corresponding manager instance.
 <<PCM base: public>>=
   public :: pcm_t
 <<PCM base: types>>=
   type, abstract :: pcm_t
      logical :: initialized = .false.
      logical :: has_pdfs = .false.
   contains
   <<PCM base: pcm: TBP>>
   end type pcm_t
 
 @ %def pcm_t
 @ The factory method.  We use the [[inout]] intent, so calling this
 again is an error.
 <<PCM base: pcm: TBP>>=
   procedure(pcm_allocate_instance), deferred :: allocate_instance
 <<PCM base: interfaces>>=
   abstract interface
      subroutine pcm_allocate_instance (pcm, instance)
        import
        class(pcm_t), intent(in) :: pcm
        class(pcm_instance_t), intent(inout), allocatable :: instance
      end subroutine pcm_allocate_instance
   end interface
 
 @ %def pcm_allocate_instance
 @
 <<PCM base: pcm: TBP>>=
   procedure(pcm_is_nlo), deferred :: is_nlo
 <<PCM base: interfaces>>=
   abstract interface
      function pcm_is_nlo (pcm) result (is_nlo)
         import
         logical :: is_nlo
         class(pcm_t), intent(in) :: pcm
      end function pcm_is_nlo
   end interface
 
 @ %def pcm_is_nlo
 @
 <<PCM base: pcm: TBP>>=
   procedure(pcm_final), deferred :: final
 <<PCM base: interfaces>>=
   abstract interface
      subroutine pcm_final (pcm)
         import
         class(pcm_t), intent(inout) :: pcm
      end subroutine pcm_final
   end interface
 
 @ %def pcm_final
 @
 \subsection{Manager instance}
 This object deals with the actual (squared) matrix element values.
 <<PCM base: public>>=
   public :: pcm_instance_t
 <<PCM base: types>>=
   type, abstract :: pcm_instance_t
     class(pcm_t), pointer :: config => null ()
     logical :: bad_point = .false.
   contains
   <<PCM base: pcm instance: TBP>>
   end type pcm_instance_t
 
 @ %def pcm_instance_t
 @
 <<PCM base: pcm instance: TBP>>=
   procedure(pcm_instance_final), deferred :: final
 <<PCM base: interfaces>>=
   abstract interface
      subroutine pcm_instance_final (pcm_instance)
         import
         class(pcm_instance_t), intent(inout) :: pcm_instance
      end subroutine pcm_instance_final
   end interface
 
 @ %def pcm_instance_final
 @
 <<PCM base: pcm instance: TBP>>=
   procedure :: link_config => pcm_instance_link_config
 <<PCM base: procedures>>=
   subroutine pcm_instance_link_config (pcm_instance, config)
      class(pcm_instance_t), intent(inout) :: pcm_instance
      class(pcm_t), intent(in), target :: config
      pcm_instance%config => config
   end subroutine pcm_instance_link_config
 
 @ %def pcm_instance_link_config
 @
 <<PCM base: pcm instance: TBP>>=
   procedure :: is_valid => pcm_instance_is_valid
 <<PCM base: procedures>>=
   function pcm_instance_is_valid (pcm_instance) result (valid)
     logical :: valid
     class(pcm_instance_t), intent(in) :: pcm_instance
     valid = .not. pcm_instance%bad_point
   end function pcm_instance_is_valid
 
 @ %def pcm_instance_is_valid
 @
 <<PCM base: pcm instance: TBP>>=
   procedure :: set_bad_point => pcm_instance_set_bad_point
 <<PCM base: procedures>>=
   pure subroutine pcm_instance_set_bad_point (pcm_instance, bad_point)
     class(pcm_instance_t), intent(inout) :: pcm_instance
     logical, intent(in) :: bad_point
     pcm_instance%bad_point = pcm_instance%bad_point .or. bad_point
   end subroutine pcm_instance_set_bad_point
 
 @ %def pcm_instance_set_bad_point
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Manager configuration}
 This object holds information about the cores used by the components
 and allocates the corresponding manager instance.
 <<[[core_manager.f90]]>>=
 <<File header>>
 
 module core_manager
 
   use format_utils, only: write_integer_array, write_separator
   use physics_defs, only: BORN, NLO_REAL
   use io_units
   use prc_core
 
 <<Standard module head>>
 
 <<Core manager: public>>
 
 <<Core manager: parameters>>
 
 <<Core manager: types>>
 
 contains
 
 <<Core manager: procedures>>
 
 end module core_manager
 @ %def core_manager
 @ Auxilliary container for polymorphic cores.
 <<Core manager: types>>=
   type :: generic_core_t
     class(prc_core_t), allocatable :: core
   end type  generic_core_t
 
 @ %def generic_core_t
 @
 <<Core manager: parameters>>=
   integer, parameter, public :: N_MAX_CORES = 100
 
 @
 <<Core manager: public>>=
   public :: core_manager_t
 <<Core manager: types>>=
   type :: core_manager_t
     integer, dimension(N_MAX_CORES) :: i_component_to_i_core = 0
     integer, dimension(N_MAX_CORES) :: i_core = 0
     logical, dimension(N_MAX_CORES) :: sub = .false.
     character(32), dimension(N_MAX_CORES) :: md5s = ""
     integer, dimension(N_MAX_CORES) :: nlo_type
     integer :: n_cores = 0
     integer, dimension(:), allocatable :: i_core_to_first_i_component
     type(generic_core_t), dimension(:), allocatable :: cores
     integer :: current_index = 1
   contains
   <<Core manager: cm: TBP>>
   end type core_manager_t
 
 @ %def core_manager_t
 @
 <<Core manager: cm: TBP>>=
   procedure :: register_new => cm_register_new
 <<Core manager: procedures>>=
   subroutine cm_register_new (cm, nlo_type, i_component, md5sum)
     class(core_manager_t), intent(inout) :: cm
     integer, intent(in) :: nlo_type, i_component
     character(32), intent(in) :: md5sum
     cm%nlo_type(cm%current_index) = nlo_type
     cm%md5s(cm%current_index) = md5sum
     cm%i_component_to_i_core(i_component) = cm%current_index
     cm%i_core(cm%current_index) = cm%current_index
     cm%current_index = cm%current_index + 1
   end subroutine cm_register_new
 
 @ %def cm_register_new
 @
 <<Core manager: cm: TBP>>=
   procedure :: register_existing => cm_register_existing
 <<Core manager: procedures>>=
   subroutine cm_register_existing (cm, i_existing, i_component)
     class(core_manager_t), intent(inout) :: cm
     integer, intent(in) :: i_existing, i_component
     integer :: i_core
     i_core = cm%i_component_to_i_core(i_existing)
     cm%i_component_to_i_core(i_component) = i_core
   end subroutine cm_register_existing
 
 @ %def cm_register_existing
 @
 <<Core manager: cm: TBP>>=
   procedure :: allocate_core_array => cm_allocate_core_array
 <<Core manager: procedures>>=
   subroutine cm_allocate_core_array (cm)
     class(core_manager_t), intent(inout) :: cm
     cm%n_cores = count (cm%i_core > 0)
     allocate (cm%cores (cm%n_cores))
   end subroutine cm_allocate_core_array
 
 @ %def cm_allocate_core_array
 @
 <<Core manager: cm: TBP>>=
   procedure :: create_i_core_to_first_i_component &
      => core_manager_create_i_core_to_first_i_component
 <<Core manager: procedures>>=
   subroutine core_manager_create_i_core_to_first_i_component (cm, n_components)
     class(core_manager_t), intent(inout) :: cm
     integer, intent(in) :: n_components
     integer :: i, i_core
     allocate (cm%i_core_to_first_i_component (cm%n_cores))
     cm%i_core_to_first_i_component = 0
     do i = 1, n_components
        if (.not. any (cm%i_core_to_first_i_component == i)) then
           i_core = cm%i_component_to_i_core (i)
           cm%i_core_to_first_i_component(i_core) = i
        end if
     end do
   end subroutine core_manager_create_i_core_to_first_i_component
 
 @ %def core_manager_create_i_core_to_first_i_component
 @
 <<Core manager: cm: TBP>>=
   procedure :: allocate_core => cm_allocate_core
 <<Core manager: procedures>>=
   subroutine cm_allocate_core (cm, i_core, core_template)
     class(core_manager_t), intent(inout) :: cm
     integer, intent(in) :: i_core
     class(prc_core_t), intent(in) :: core_template
     allocate (cm%cores(i_core)%core, source = core_template)
   end subroutine cm_allocate_core
 
 @ %def cm_allocate_core
 @
 <<Core manager: cm: TBP>>=
   procedure :: get_core => cm_get_core
 <<Core manager: procedures>>=
   function cm_get_core (cm, i_core) result (core)
     class(prc_core_t), pointer :: core
     class(core_manager_t), intent(in), target :: cm
     integer, intent(in) :: i_core
     core => cm%cores(i_core)%core
   end function cm_get_core
 
 @ %def cm_get_core
 @
 <<Core manager: cm: TBP>>=
   procedure :: get_subtraction_core => cm_get_subtraction_core
 <<Core manager: procedures>>=
   function cm_get_subtraction_core (cm) result (core)
     class(prc_core_t), pointer :: core
     class(core_manager_t), intent(in), target :: cm
     integer :: i
     core => null ()
     do i = 1, cm%n_cores
        if (cm%sub(i)) then
           core => cm%cores(i)%core
           exit
        end if
     end do
   end function cm_get_subtraction_core
 
 @ %def cm_get_subtraction_core
 @
 <<Core manager: cm: TBP>>=
   procedure :: get_flv_states => cm_get_flv_states
 <<Core manager: procedures>>=
   pure subroutine cm_get_flv_states (cm, flv_born, flv_real, n_in)
     class(core_manager_t), intent(in) :: cm
     integer, dimension(:,:), allocatable, intent(out) :: flv_born, flv_real
     integer, intent(out) :: n_in
     integer :: i
     do i = 1, cm%n_cores
        if (cm%nlo_type(i) == BORN) then
           if (.not. allocated (flv_born)) &
              allocate (flv_born (size (cm%cores(i)%core%data%flv_state, 1), &
                 size (cm%cores(i)%core%data%flv_state, 2)))
           flv_born = cm%cores(i)%core%data%flv_state
           n_in = cm%cores(i)%core%data%n_in
        else if (cm%nlo_type(i) == NLO_REAL) then
           if (.not. allocated (flv_real)) &
              allocate (flv_real (size (cm%cores(i)%core%data%flv_state, 1), &
                 size (cm%cores(i)%core%data%flv_state, 2)))
           flv_real = cm%cores(i)%core%data%flv_state
           n_in = cm%cores(i)%core%data%n_in
        end if
     end do
   end subroutine cm_get_flv_states
 
 @ %def cm_get_flv_states
 @
 <<Core manager: cm: TBP>>=
   procedure :: core_is_radiation => cm_core_is_radiation
 <<Core manager: procedures>>=
   elemental function cm_core_is_radiation (cm, i_core) result (is_rad)
     logical :: is_rad
     class(core_manager_t), intent(in) :: cm
     integer, intent(in) :: i_core
     is_rad = cm%nlo_type(i_core) == NLO_REAL .and. .not. cm%sub(i_core)
   end function cm_core_is_radiation
 
 @ %def cm_core_is_radiation
 @ Asterisks denote the subtraction components
 <<Core manager: cm: TBP>>=
   procedure :: write => cm_write
 <<Core manager: procedures>>=
   subroutine cm_write (cm, unit)
     class(core_manager_t), intent(in) :: cm
     integer, intent(in), optional :: unit
     integer :: u, i
     u = given_output_unit (unit);  if (u < 0)  return
     write (u,"(1x,A,I1,A)") "component manager instance with ", cm%n_cores, " cores: "
     write (u,"(1x,A)") "(* denotes subtraction cores)"
     write (u,"(1x,A,L1)") 'Cores allocated? ', allocated (cm%cores)
     do i = 1, cm%n_cores
        write (u,"(1x,A,I1,A)", advance = "no") "Core nr. ", i, ": "
        if (cm%sub(i)) write (u,"(A)", advance = "no") "*"
        call cm%cores(i)%core%write_name (u)
     end do
     call write_separator (u, 1)
     write (u,"(1x,A)") "i_component -> i_core: "
     do i = 1, N_MAX_CORES
        if (cm%i_component_to_i_core(i) > 0) then
           write (u, "(I0, A)", advance = "no") cm%i_component_to_i_core(i), ", "
        else
           write (u, "(A)") ""
           exit
        end if
     end do
     call write_separator (u, 1)
     if (allocated (cm%i_core_to_first_i_component)) then
        write (u, "(1x,A)") "i_core -> i_component_first: "
        call write_integer_array (cm%i_core_to_first_i_component, &
           unit = u, n_max = cm%n_cores)
     else
        write (u, "(1X,A)") "cm%i_core_to_first_i_component: Not allocated."
     end if
     call write_separator (u, 1)
     write (u,"(1x,A)") "nlo type -> i_core: "
     call write_integer_array (cm%i_core, unit = u, n_max = cm%n_cores)
     call write_separator (u, 1)
     write (u, "(1x,A)") "Md5 sums: "
     do i = 1, cm%n_cores
        write (u, "(A,A)") cm%md5s(i)
     end do
     call write_separator (u, 1)
   end subroutine cm_write
 
 @ %def cm_write
 @
 <<Core manager: cm: TBP>>=
   procedure :: final => cm_final
 <<Core manager: procedures>>=
   subroutine cm_final (cm)
     class(core_manager_t), intent(inout) :: cm
     cm%i_component_to_i_core = 0
     cm%n_cores = 0
     cm%i_core = 0
     cm%nlo_type = 0
     cm%md5s = ""
     cm%current_index = 1
     if (allocated (cm%cores)) deallocate (cm%cores)
     if (allocated (cm%i_core_to_first_i_component)) &
        deallocate (cm%i_core_to_first_i_component)
   end subroutine cm_final
 
 
 @ %def cm_final
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{The process object}
 <<[[process.f90]]>>=
 <<File header>>
 
 module process
 
 <<Use kinds>>
 <<Use strings>>
   use io_units
   use format_utils, only: write_separator
   use constants
   use diagnostics
   use numeric_utils
   use lorentz
   use cputime
   use md5
   use rng_base
   use os_interface
   use sm_qcd
   use integration_results
   use mci_base
   use flavors
   use model_data
   use models
   use physics_defs
   use process_libraries
   use process_constants
   use particles
   use variables
   use beam_structures
   use beams
   use interactions
   use pdg_arrays
   use expr_base
   use sf_base
   use sf_mappings
   use resonances, only: resonance_history_t, resonance_history_set_t
 
   use prc_test_core, only: test_t
   use prc_core, only: prc_core_t
   use prc_user_defined, only: prc_user_defined_base_t
   use prc_recola, only: prc_recola_t
   use blha_olp_interfaces, only: prc_blha_t, blha_template_t
   use prc_threshold, only: prc_threshold_t
 
   use phs_base
   use phs_wood, only: phs_wood_config_t
   use phs_wood, only: EXTENSION_DEFAULT, EXTENSION_DGLAP
   use phs_fks, only: phs_fks_config_t, get_filtered_resonance_histories
   use blha_config, only: blha_master_t
   use nlo_data, only: FKS_DEFAULT, FKS_RESONANCES
   use nlo_data, only: fks_template_t
 
   use parton_states, only: connected_state_t
   use pcm_base
   use pcm
   use process_counter
   use core_manager
   use process_config
   use process_mci
 
 <<Standard module head>>
 
 <<Process: public>>
 
 <<Process: types>>
 
 contains
 
 <<Process: procedures>>
 
 end module process
 @ %def process
 A process object is the workspace for the process instance.
 After initialization, its contents are filled by
 integration passes which shape the integration grids and compute cross
 sections.  Processes are set up initially from user-level
 configuration data.  After calculating integrals and thus developing
 integration grid data, the program may use a process
 object or a copy of it for the purpose of generating events.
 
 The process object consists of several subobjects with their specific
 purposes.  The corresponding types are defined below.  (Technically,
 the subobject type definitions have to come before the process type
 definition, but with NOWEB magic we reverse this order here.)
 
 The [[type]] determines whether we are considering a decay or a
 scattering process.
 
 The [[meta]] object describes the process and its environment.  All
 contents become fixed when the object is initialized.
 
 The [[config]] object holds physical and technical configuration data
 that have been obtained during process initialization, and which are
 common to all process components.
 
 The individual process components are configured in the [[component]]
 objects.  These objects contain more configuration parameters and
 workspace, as needed for the specific process variant.
 
 The [[term]] objects describe parton configurations which are
 technically used as phase-space points.  Each process component may
 split into several terms with distinct kinematics and particle
 content.  Furthermore, each term may project on a different physical
 state, e.g., by particle recombination.  The [[term]] object provides
 the framework for this projection, for applying cuts, weight, and thus
 completing the process calculation.
 
 The [[beam_config]] object describes the incoming particles, either the
 decay mother or the scattering beams.  It also contains the structure-function
 information.
 
 The [[mci_entry]] objects configure a MC input parameter set and integrator,
 each.  The number of parameters depends on the process component and on the
 beam and structure-function setup.
 
 The [[pcm]] component is the process-component manager.  This
 polymorphic object manages and hides the details of dealing with NLO
 processes where several components have to be combined in a
 non-trivial way.  It also acts as an abstract factory for the
 corresponding object in [[process_instance]], which does the actual
 work for this matter.
 <<Process: public>>=
   public :: process_t
 <<Process: types>>=
   type :: process_t
      private
      type(process_metadata_t) :: &
           meta
      type(process_config_data_t) :: &
           config
      type(process_counter_t) :: &
           counter
      type(process_component_t), dimension(:), allocatable :: &
           component
      type(process_term_t), dimension(:), allocatable :: &
           term
      type(process_beam_config_t) :: &
           beam_config
      type(process_mci_entry_t), dimension(:), allocatable :: &
           mci_entry
      class(pcm_t), allocatable :: &
           pcm
      type(core_manager_t) :: cm
      logical, dimension(:), allocatable :: component_selected
    contains
    <<Process: process: TBP>>
   end type process_t
 
 @ %def process_t
 @
 \subsection{Set of resonant subprocesses}
 Wrapper type for storing pointers to process objects in arrays.
 <<Process: public>>=
   public :: process_ptr_t
 <<Process: types>>=
   type :: process_ptr_t
      type(process_t), pointer :: p => null ()
   end type process_ptr_t
 
 @ %def process_ptr_t
 @
 This procedure is an important debugging and inspection tool; it is
 not used during normal operation.  The process object is written
 to a file (identified by unit, which may also be standard output).
 Optional flags determine whether we show everything or just the
 interesting parts.
 <<Process: process: TBP>>=
   procedure :: write => process_write
 <<Process: procedures>>=
   subroutine process_write (process, screen, unit, &
        show_all, show_var_list, &
        show_os_data, &
        show_rng_factory, show_model, show_expressions, &
        show_sfchain, &
        show_equivalences, show_history, show_histories, &
        show_forest, show_x, &
        show_subevt, show_evaluators, pacify)
     class(process_t), intent(in) :: process
     logical, intent(in) :: screen
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: show_all
     logical, intent(in), optional :: show_var_list
     logical, intent(in), optional :: show_os_data
     logical, intent(in), optional :: show_rng_factory
     logical, intent(in), optional :: show_model, show_expressions
     logical, intent(in), optional :: show_sfchain
     logical, intent(in), optional :: show_equivalences
     logical, intent(in), optional :: show_history, show_histories
     logical, intent(in), optional :: show_forest, show_x
     logical, intent(in), optional :: show_subevt, show_evaluators
     logical, intent(in), optional :: pacify
     logical :: all
     logical :: var_list
     logical :: counters
     logical :: os_data
     logical :: rng_factory, model, expressions
     integer :: u, i
     u = given_output_unit (unit)
     if (present (show_all)) then
        all = show_all
     else
        all = .false.
     end if
     var_list = .false.
     counters = .true.
     os_data = .false.
     model = .false.
     rng_factory = .true.
     expressions = .false.
     if (present (show_var_list)) then
        all = .false.; var_list = show_var_list
     end if
     if (present (show_os_data)) then
        all = .false.; os_data = show_os_data
     end if
     if (present (show_rng_factory)) then
        all = .false.; rng_factory = show_rng_factory
     end if
     if (present (show_model)) then
        all = .false.; model = show_model
     end if
     if (present (show_expressions)) then
        all = .false.; expressions = show_expressions
     end if
     if (all) then
        var_list = .true.
        rng_factory = .true.
        model = .true.
        expressions = .true.
     end if
     if (screen) then
        write (msg_buffer, "(A)")  repeat ("-", 72)
        call msg_message ()
     else
        call write_separator (u, 2)
     end if
     call process%meta%write (u, var_list, screen)
     if (process%meta%type == PRC_UNKNOWN) then
        call write_separator (u, 2)
        return
     else
        if (.not. screen)  call write_separator (u)
     end if
     if (screen)  return
     call process%config%write &
          (u, counters, os_data, rng_factory, model, expressions)
     call write_separator (u, 2)
     if (allocated (process%component)) then
        write (u, "(1x,A)") "Process component configuration:"
        do i = 1, size (process%component)
           call write_separator (u)
           call process%component(i)%write (u)
        end do
     else
        write (u, "(1x,A)") "Process component configuration: [undefined]"
     end if
     call write_separator (u, 2)
     if (allocated (process%term)) then
        write (u, "(1x,A)") "Process term configuration:"
        do i = 1, size (process%term)
           call write_separator (u)
           call process%term(i)%write (u)
        end do
     else
        write (u, "(1x,A)") "Process term configuration: [undefined]"
     end if
     call write_separator (u, 2)
     call process%beam_config%write (u)
     call write_separator (u, 2)
     if (allocated (process%mci_entry)) then
        write (u, "(1x,A)") "Multi-channel integrator configurations:"
        do i = 1, size (process%mci_entry)
           call write_separator (u)
           write (u, "(1x,A,I0,A)")  "MCI #", i, ":"
           call process%mci_entry(i)%write (u, pacify)
        end do
     end if
     call write_separator (u, 2)
   end subroutine process_write
 
 @ %def process_write
 @
 <<Process: process: TBP>>=
   procedure :: write_meta => process_write_meta
 <<Process: procedures>>=
   subroutine process_write_meta (process, unit, testflag)
     class(process_t), intent(in) :: process
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: testflag
     integer :: u, i
     u = given_output_unit (unit)
     select case (process%meta%type)
     case (PRC_UNKNOWN)
        write (u, "(1x,A)") "Process instance [undefined]"
        return
     case (PRC_DECAY)
        write (u, "(1x,A)", advance="no") "Process instance [decay]:"
     case (PRC_SCATTERING)
        write (u, "(1x,A)", advance="no") "Process instance [scattering]:"
     case default
        call msg_bug ("process_instance_write: undefined process type")
     end select
     write (u, "(1x,A,A,A)") "'", char (process%meta%id), "'"
     write (u, "(3x,A,A,A)") "Run ID = '", char (process%meta%run_id), "'"
     if (allocated (process%meta%component_id)) then
        write (u, "(3x,A)")  "Process components:"
        do i = 1, size (process%meta%component_id)
           if (process%component_selected (i)) then
              write (u, "(3x,'*')", advance="no")
           else
              write (u, "(4x)", advance="no")
           end if
           write (u, "(1x,I0,9A)")  i, ": '", &
                char (process%meta%component_id (i)), "':   ", &
                char (process%meta%component_description (i))
        end do
     end if
   end subroutine process_write_meta
 
 @ %def process_write_meta
 @ Screen output.  Write a short account of the process configuration
 and the current results.  The verbose version lists the components,
 the short version just the results.
 <<Process: process: TBP>>=
   procedure :: show => process_show
 <<Process: procedures>>=
   subroutine process_show (object, unit, verbose)
     class(process_t), intent(in) :: object
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose
     integer :: u
     logical :: verb
     real(default) :: err_percent
     u = given_output_unit (unit)
     verb = .true.;  if (present (verbose)) verb = verbose
     if (verb) then
        call object%meta%show (u, object%config%model%get_name ())
        select case (object%meta%type)
        case (PRC_DECAY)
           write (u, "(2x,A)", advance="no")  "Computed width ="
        case (PRC_SCATTERING)
           write (u, "(2x,A)", advance="no")  "Computed cross section ="
        case default;  return
        end select
     else
        if (object%meta%run_id /= "") then
           write (u, "('Run',1x,A,':',1x)", advance="no") &
                char (object%meta%run_id)
        end if
        write (u, "(A)", advance="no") char (object%meta%id)
        select case (object%meta%num_id)
        case (0)
           write (u, "(':')")
        case default
           write (u, "(1x,'(',I0,')',':')") object%meta%num_id
        end select
        write (u, "(2x)", advance="no")
     end if
     if (object%has_integral_tot ()) then
        write (u, "(ES14.7,1x,'+-',ES9.2)", advance="no") &
             object%get_integral_tot (), object%get_error_tot ()
        select case (object%meta%type)
        case (PRC_DECAY)
           write (u, "(1x,A)", advance="no")  "GeV"
        case (PRC_SCATTERING)
           write (u, "(1x,A)", advance="no")  "fb "
        case default
           write (u, "(1x,A)", advance="no")  "   "
        end select
        if (object%get_integral_tot () /= 0) then
           err_percent = abs (100 &
                * object%get_error_tot () / object%get_integral_tot ())
        else
           err_percent = 0
        end if
        if (err_percent == 0) then
           write (u, "(1x,'(',F4.0,4x,'%)')")  err_percent
        else if (err_percent < 0.1) then
           write (u, "(1x,'(',F7.3,1x,'%)')")  err_percent
        else if (err_percent < 1) then
           write (u, "(1x,'(',F6.2,2x,'%)')")  err_percent
        else if (err_percent < 10) then
           write (u, "(1x,'(',F5.1,3x,'%)')")  err_percent
        else
           write (u, "(1x,'(',F4.0,4x,'%)')")  err_percent
        end if
     else
        write (u, "(A)")  "[integral undefined]"
     end if
   end subroutine process_show
 
 @ %def process_show
 @ Finalizer.  Explicitly iterate over all subobjects that may contain
 allocated pointers.
 
 TODO (workaround): The finalizer for the [[config_data]] component is not
 called.  The reason is that this deletes model data local to the process,
 but these could be referenced by pointers (flavor objects) from some
 persistent event record.  Obviously, such side effects should be avoided, but
 this requires refactoring the event-handling procedures.
 <<Process: process: TBP>>=
   procedure :: final => process_final
 <<Process: procedures>>=
   subroutine process_final (process)
     class(process_t), intent(inout) :: process
     integer :: i
     call process%meta%final ()
     ! call process%config%final ()
     if (allocated (process%component)) then
        do i = 1, size (process%component)
           call process%component(i)%final ()
        end do
     end if
     if (allocated (process%term)) then
        do i = 1, size (process%term)
           call process%term(i)%final ()
        end do
     end if
     call process%beam_config%final ()
     if (allocated (process%mci_entry)) then
        do i = 1, size (process%mci_entry)
           call process%mci_entry(i)%final ()
        end do
     end if
     call process%cm%final ()
     if (allocated (process%pcm)) then
        call process%pcm%final ()
        deallocate (process%pcm)
     end if
   end subroutine process_final
 
 @ %def process_final
 @
 \subsubsection{Process setup}
 Initialize a process.  We need a process library, the name of the process,
 and a run ID.  The model is imported via its pointer, and the original pointer
 freed.
 <<Process: process: TBP>>=
   procedure :: init => process_init
 <<Process: procedures>>=
   subroutine process_init (process, proc_id, run_id, &
        lib, os_data, qcd, rng_factory, model)
     class(process_t), intent(out) :: process
     type(string_t), intent(in) :: proc_id
     type(string_t), intent(in) :: run_id
     type(process_library_t), intent(in), target :: lib
     type(os_data_t), intent(in) :: os_data
     type(qcd_t), intent(in) :: qcd
     class(rng_factory_t), intent(inout), allocatable :: rng_factory
     class(model_data_t), intent(inout), pointer :: model
     call msg_debug (D_PROCESS_INTEGRATION, "process_init")
     if (.not. lib%is_active ()) then
        call msg_bug ("Process init: inactive library not handled yet")
     end if
     if (.not. lib%contains (proc_id)) then
        call msg_fatal ("Process library doesn't contain process '" &
             // char (proc_id) // "'")
        return
     end if
     associate (meta => process%meta)
       call meta%init (proc_id, run_id, lib)
       call process%config%init &
            (meta, os_data, qcd, rng_factory, model)
       allocate (process%component (meta%n_components))
       allocate (process%component_selected (meta%n_components))
       process%component_selected = .false.
     end associate
     if (.not. lib%get_nlo_process (proc_id)) then
        allocate (pcm_default_t :: process%pcm)
     else
        allocate (pcm_nlo_t :: process%pcm)
     end if
   end subroutine process_init
 
 @ %def process_init
 @ Store a snapshot of the common variable list.
 <<Process: process: TBP>>=
   procedure :: set_var_list => process_set_var_list
 <<Process: procedures>>=
   subroutine process_set_var_list (process, var_list)
     class(process_t), intent(inout) :: process
     type(var_list_t), intent(in) :: var_list
     call var_list_init_snapshot &
          (process%meta%var_list, var_list, follow_link=.true.)
   end subroutine process_set_var_list
 
 @ %def process_set_var_list
 @
 <<Process: process: TBP>>=
   procedure :: core_manager_register => process_core_manager_register
   procedure :: core_manager_register_default => process_core_manager_register_default
   procedure :: core_manager_register_sub => process_core_manager_register_sub
 <<Process: procedures>>=
   subroutine process_core_manager_register (process, &
      nlo_type, i_component, type_string)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: nlo_type, i_component
     type(string_t), intent(in), optional :: type_string
     select case (nlo_type)
     case (NLO_SUBTRACTION)
        call process%core_manager_register_sub (nlo_type, i_component, type_string)
     case (NLO_MISMATCH)
        process%cm%i_component_to_i_core(i_component) = &
             process%get_i_core_nlo_type (NLO_SUBTRACTION, .true.)
     case default
        call process%core_manager_register_default (nlo_type, i_component, type_string)
     end select
   end subroutine process_core_manager_register
 
   subroutine process_core_manager_register_sub (process, nlo_type, i_component, type_string)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: nlo_type, i_component
     type(string_t), intent(in), optional :: type_string
     character(32) :: md5sum
     integer :: i
     md5sum = process%get_md5sum_constants (i_component, type_string, nlo_type)
     if (any (process%cm%md5s == md5sum)) then
        do i = 1, N_MAX_CORES
           if (process%cm%i_core(i) == 0) exit
           if (md5sum == process%cm%md5s(i)) then
             process%cm%sub(i) = .true.
          end if
        end do
     else
        process%cm%sub(process%cm%current_index) = .true.
        call process%cm%register_new (nlo_type, i_component, md5sum)
     end if
   end subroutine process_core_manager_register_sub
 
   subroutine process_core_manager_register_default &
      (process, nlo_type, i_component, type_string)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: nlo_type, i_component
     type(string_t), intent(in), optional :: type_string
     character(32) :: md5sum
     integer :: i
     logical :: check
     md5sum = process%get_md5sum_constants (i_component, type_string, nlo_type)
     check = .false.
     associate (cm => process%cm)
        if (.not. any (cm%md5s == md5sum)) then
           call cm%register_new (nlo_type, i_component, md5sum)
        else
           do i = 1, N_MAX_CORES
              if (cm%md5s(i) == md5sum) then
                 call cm%register_existing (i, i_component)
                 check = .true.
                 exit
              end if
           end do
           if (.not. check) call msg_fatal ("Register core: Inconsistency encountered!")
        end if
     end associate
   end subroutine process_core_manager_register_default
 
 @ %def process_core_manager_register
 @
 <<Process: process: TBP>>=
   procedure :: allocate_cm_arrays => process_allocate_cm_arrays
 <<Process: procedures>>=
   subroutine process_allocate_cm_arrays (process, n_components)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: n_components
     call process%cm%allocate_core_array ()
     call process%cm%create_i_core_to_first_i_component (n_components)
   end subroutine process_allocate_cm_arrays
 
 @ %def process_allocate_cm_arrays
 @
 <<Process: process: TBP>>=
   procedure :: allocate_core => process_allocate_core
 <<Process: procedures>>=
   subroutine process_allocate_core (process, i_core, core_template)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_core
     class(prc_core_t), intent(in) :: core_template
     call process%cm%allocate_core (i_core, core_template)
   end subroutine process_allocate_core
 
 @ %def process_allocate_core
 @ Initialize the process components, one by one, using a template for
 the process core object.  The template is taken only for allocating
 the correct type; the contents are set by extracting the process entry
 from the library.
 <<Process: process: TBP>>=
   procedure :: init_component => process_init_component
 <<Process: procedures>>=
   subroutine process_init_component &
        (process, index, active, mci_template, phs_config_template)
     class(process_t), intent(inout), target :: process
     integer, intent(in) :: index
     logical, intent(in) :: active
     class(mci_t), intent(in), allocatable :: mci_template
     class(phs_config_t), intent(in), allocatable :: phs_config_template
     type(process_constants_t) :: data
     call process%meta%lib%fill_constants (process%meta%id, index, data)
     associate (component => process%component(index))
        call component%init (index, &
             process%meta, process%config, &
             active, data, &
             mci_template, phs_config_template)
        if (.not. component%active .and. &
             component%config%get_nlo_type () /= NLO_SUBTRACTION) &
             call process%meta%deactivate_component(index)
     end associate
   end subroutine process_init_component
 
 @ %def process_init_component
 @ Determine the process terms for each process component.
 <<Process: process: TBP>>=
   procedure :: setup_terms => process_setup_terms
 <<Process: procedures>>=
   subroutine process_setup_terms (process, with_beams)
     class(process_t), intent(inout), target :: process
     logical, intent(in), optional :: with_beams
     class(model_data_t), pointer :: model
     integer :: i, j, k, i_term
     integer, dimension(:), allocatable :: n_entry
     integer :: n_components, n_tot
     integer :: i_sub
     type(string_t) :: subtraction_method
     class(prc_core_t), pointer :: core => null ()
     logical :: setup_subtraction_component, singular_real
     integer :: nlo_type_to_fetch
     i_sub = 0
     model => process%config%model
     n_components = process%meta%n_components
     allocate (n_entry (n_components), source = 0)
     do i = 1, n_components
        associate (component => process%component(i))
          if (component%active) then
             n_entry(i) = 1
             if (component%get_nlo_type () == NLO_REAL) then
                select type (pcm => process%pcm)
                type is (pcm_nlo_t)
                   if (component%component_type /= COMP_REAL_FIN) &
                        n_entry(i) = n_entry(i) + pcm%region_data%get_n_phs ()
                end select
             end if
          end if
        end associate
     end do
     n_tot = sum (n_entry)
     allocate (process%term (n_tot))
     k = 0
     if (process%is_nlo_calculation ()) then
        i_sub = process%component(1)%config%get_associated_subtraction ()
        subtraction_method = process%component(i_sub)%config%get_me_method ()
        call msg_debug2 (D_PROCESS_INTEGRATION, "process_setup_terms: ", &
             subtraction_method)
     end if
 
     do i = 1, n_components
        associate (component => process%component(i))
          if (.not. component%active)  cycle
            allocate (component%i_term (n_entry(i)))
            do j = 1, n_entry(i)
               singular_real = component%get_nlo_type () == NLO_REAL &
                    .and. component%component_type /= COMP_REAL_FIN
               setup_subtraction_component = singular_real .and. j == n_entry(i)
               i_term = k + j
               component%i_term(j) = i_term
               if (singular_real) then
                  process%term(i_term)%i_sub = k + n_entry(i)
               else
                  process%term(i_term)%i_sub = 0
               end if
               nlo_type_to_fetch = component%get_nlo_type ()
               if (nlo_type_to_fetch == NLO_MISMATCH)  nlo_type_to_fetch = NLO_SUBTRACTION
               process%term(i_term)%i_core = set_i_core (i, nlo_type_to_fetch, &
                    setup_subtraction_component, component%config%get_def_type_string ())
               if (process%term(i_term)%i_core == 0) then
                  call msg_bug ("Process '" // char (process%get_id ()) &
                       // "': core not found!")
               end if
               core => process%get_core_term (i_term)
               process%term(i_term)%pcm => process%pcm
               if (i_sub > 0) then
                  select type (pcm => process%pcm)
                  type is (pcm_nlo_t)
                     call process%term(i_term)%init (i_term, i, j, core, model, &
                          nlo_type = component%config%get_nlo_type (), &
                          use_beam_pol = with_beams, &
                          subtraction_method = subtraction_method)
                  class default
                     call process%term(i_term)%init (i_term, i, j, core, model, &
                          nlo_type = component%config%get_nlo_type (), &
                          use_beam_pol = with_beams, &
                          subtraction_method = subtraction_method)
                  end select
               else
                  call process%term(i_term)%init (i_term, i, j, core, model, &
                       nlo_type = component%config%get_nlo_type (), &
                       use_beam_pol = with_beams)
               end if
            end do
        end associate
        k = k + n_entry(i)
     end do
     process%config%n_terms = n_tot
   contains
     function set_i_core (i_component, nlo_type, sub, type_string) result (i_core)
       integer :: i_core
       integer, intent(in) :: i_component, nlo_type
       logical, intent(in) :: sub
       type(string_t), intent(in) :: type_string
       character(32) :: md5sum
       integer :: index
       i_core = 0
       md5sum = process%get_md5sum_constants (i_component, type_string, nlo_type)
       do index = 1, N_MAX_CORES
          if (sub) then
             if (process%cm%sub(index)) then
                 i_core = index
                 exit
             end if
          else
             i_core = process%cm%i_core(index)
             if (process%cm%md5s(index) == md5sum) then
                i_core = index
                exit
             end if
          end if
       end do
     end function set_i_core
   end subroutine process_setup_terms
 
 @ %def process_setup_terms
 @ Initialize the beam setup.  This is the trivial version where the
 incoming state of the matrix element coincides with the initial state
 of the process.  For a scattering process, we need the c.m. energy,
 all other variables are set to their default values (no polarization,
 lab frame and c.m.\ frame coincide, etc.)
 
 We assume that all components consistently describe a scattering
 process, i.e., two incoming particles.
 
 Note: The current layout of the [[beam_data_t]] record requires that the
 flavor for each beam is unique.  For processes with multiple
 flavors in the initial state, one has to set up beams explicitly.
 This restriction could be removed by extending the code in the
 [[beams]] module.
 <<Process: process: TBP>>=
   procedure :: setup_beams_sqrts => process_setup_beams_sqrts
 <<Process: procedures>>=
   subroutine process_setup_beams_sqrts (process, sqrts, beam_structure, i_core)
     class(process_t), intent(inout) :: process
     real(default), intent(in) :: sqrts
     type(beam_structure_t), intent(in), optional :: beam_structure
     integer, intent(in), optional :: i_core
     type(pdg_array_t), dimension(:,:), allocatable :: pdg_in
     integer, dimension(2) :: pdg_scattering
     type(flavor_t), dimension(2) :: flv_in
     integer :: i, i0, ic
     class(prc_core_t), pointer :: core => null ()
     allocate (pdg_in (2, process%meta%n_components))
     i0 = 0
     do i = 1, process%meta%n_components
        if (process%component(i)%active) then
           if (present (i_core)) then
              ic = i_core
           else
              ic = process%cm%i_component_to_i_core (i)
           end if
           core => process%cm%get_core (ic)
           pdg_in(:,i) = core%data%get_pdg_in ()
           if (i0 == 0)  i0 = i
        end if
     end do
     do i = 1, process%meta%n_components
        if (.not. process%component(i)%active) then
           pdg_in(:,i) = pdg_in(:,i0)
        end if
     end do
     if (all (pdg_array_get_length (pdg_in) == 1) .and. &
          all (pdg_in(1,:) == pdg_in(1,i0)) .and. &
          all (pdg_in(2,:) == pdg_in(2,i0))) then
        pdg_scattering = pdg_array_get (pdg_in(:,i0), 1)
        call flv_in%init (pdg_scattering, process%config%model)
        call process%beam_config%init_scattering (flv_in, sqrts, beam_structure)
     else
        call msg_fatal ("Setting up process '" // char (process%meta%id) // "':", &
            [var_str ("   --------------------------------------------"), &
             var_str ("Inconsistent initial state. This happens if either "), &
             var_str ("several processes with non-matching initial states "), &
             var_str ("have been added, or for a single process with an "), &
             var_str ("initial state flavor sum. In that case, please set beams "), &
             var_str ("explicitly [singling out a flavor / structure function.]")])
     end if
   end subroutine process_setup_beams_sqrts
 
 @ %def process_setup_beams_sqrts
 @ This is the version that applies to decay processes.  The energy is the
 particle mass, hence no extra argument.
 <<Process: process: TBP>>=
   procedure :: setup_beams_decay => process_setup_beams_decay
 <<Process: procedures>>=
   subroutine process_setup_beams_decay (process, rest_frame, beam_structure, i_core)
     class(process_t), intent(inout) :: process
     logical, intent(in), optional :: rest_frame
     type(beam_structure_t), intent(in), optional :: beam_structure
     integer, intent(in), optional :: i_core
     type(pdg_array_t), dimension(:,:), allocatable :: pdg_in
     integer, dimension(1) :: pdg_decay
     type(flavor_t), dimension(1) :: flv_in
     integer :: i, i0, ic
     class(prc_core_t), pointer :: core => null ()
     allocate (pdg_in (1, process%meta%n_components))
     i0 = 0
     do i = 1, process%meta%n_components
        if (process%component(i)%active) then
           if (present (i_core)) then
              ic = i_core
           else
              ic = process%cm%i_component_to_i_core (i)
           end if
           core => process%cm%get_core (ic)
           pdg_in(:,i) = core%data%get_pdg_in ()
           if (i0 == 0)  i0 = i
        end if
     end do
     do i = 1, process%meta%n_components
        if (.not. process%component(i)%active) then
           pdg_in(:,i) = pdg_in(:,i0)
        end if
     end do
     if (all (pdg_array_get_length (pdg_in) == 1) &
          .and. all (pdg_in(1,:) == pdg_in(1,i0))) then
        pdg_decay = pdg_array_get (pdg_in(:,i0), 1)
        call flv_in%init (pdg_decay, process%config%model)
        call process%beam_config%init_decay (flv_in, rest_frame, beam_structure)
     else
        call msg_fatal ("Setting up decay '" &
             // char (process%meta%id) // "': decaying particle not unique")
     end if
   end subroutine process_setup_beams_decay
 
 @ %def process_setup_beams_decay
 @ We have to make sure that the masses of the various flavors
 in a given position in the particle string coincide.
 <<Process: process: TBP>>=
   procedure :: check_masses => process_check_masses
 <<Process: procedures>>=
   subroutine process_check_masses (process)
        class(process_t), intent(in) :: process
        type(flavor_t), dimension(:), allocatable :: flv
        real(default), dimension(:), allocatable :: mass
        integer :: i, j
        integer :: i_component
        class(prc_core_t), pointer :: core => null ()
        do i = 1, process%get_n_terms ()
           i_component = process%term(i)%i_component
           if (.not. process%component(i_component)%active)  cycle
           core => process%get_core_term (i)
           associate (data => core%data)
             allocate (flv (data%n_flv), mass (data%n_flv))
             do j = 1, data%n_in + data%n_out
                call flv%init (data%flv_state(j,:), process%config%model)
                mass = flv%get_mass ()
                if (any (.not. nearly_equal(mass, mass(1)))) then
                   call msg_fatal ("Process '" // char (process%meta%id) // "': " &
                        // "mass values in flavor combination do not coincide. ")
                end if
             end do
             deallocate (flv, mass)
           end associate
        end do
    end subroutine process_check_masses
 
 @ %def process_check_masses
 @ For some structure functions we need to get the list of initial
 state flavors.  This is a two-dimensional array.  The first index is
 the beam index, the second index is the component index.  Each array
 element is itself a PDG array object, which consists of the list of
 incoming PDG values for this beam and component.
 <<Process: process: TBP>>=
   procedure :: get_pdg_in => process_get_pdg_in
 <<Process: procedures>>=
   subroutine process_get_pdg_in (process, pdg_in)
     class(process_t), intent(in) :: process
     type(pdg_array_t), dimension(:,:), allocatable, intent(out) :: pdg_in
     integer :: i, i_core
     class(prc_core_t), pointer :: core => null ()
     allocate (pdg_in (process%config%n_in, process%meta%n_components))
     do i = 1, process%meta%n_components
        if (process%component(i)%active) then
           i_core = process%cm%i_component_to_i_core (i)
           core => process%cm%get_core (i_core)
           pdg_in(:,i) = core%data%get_pdg_in ()
        end if
     end do
     core => null ()
   end subroutine process_get_pdg_in
 
 @ %def process_get_pdg_in
 @ The phase-space configuration object, in case we need it separately.
 <<Process: process: TBP>>=
   procedure :: get_phs_config => process_get_phs_config
 <<Process: procedures>>=
   function process_get_phs_config (process, i_component) result (phs_config)
     class(phs_config_t), pointer :: phs_config
     class(process_t), intent(in), target :: process
     integer, intent(in) :: i_component
     if (allocated (process%component)) then
        phs_config => process%component(i_component)%phs_config
     else
        phs_config => null ()
     end if
   end function process_get_phs_config
 
 @ %def process_get_phs_config
 @ The resonance history set can be extracted from the phase-space
 configuration.  However, this is only possible if the default phase-space
 method (wood) has been chosen.  If [[include_trivial]] is set, we include the
 resonance history with no resonances in the set.
 <<Process: process: TBP>>=
   procedure :: extract_resonance_history_set &
        => process_extract_resonance_history_set
 <<Process: procedures>>=
   subroutine process_extract_resonance_history_set &
        (process, res_set, include_trivial, i_component)
     class(process_t), intent(in), target :: process
     type(resonance_history_set_t), intent(out) :: res_set
     logical, intent(in), optional :: include_trivial
     integer, intent(in), optional :: i_component
     integer :: i
     i = 1;  if (present (i_component))  i = i_component
     select type (phs_config => process%get_phs_config (i))
     class is (phs_wood_config_t)
        call phs_config%extract_resonance_history_set (res_set, include_trivial)
     class default
        call msg_error ("process '" // char (process%get_id ()) &
             // "': extract resonance histories: phase-space method must be &
             &'wood'.  No resonances can be determined.")
     end select
   end subroutine process_extract_resonance_history_set
 
 @ %def process_extract_resonance_history_set
 @ Initialize from a complete beam setup.  If the beam setup doesn't
 apply directly to the process, choose a fallback option as a straight
 scattering or decay process.
 <<Process: process: TBP>>=
   procedure :: setup_beams_beam_structure => process_setup_beams_beam_structure
 <<Process: procedures>>=
   subroutine process_setup_beams_beam_structure &
        (process, beam_structure, sqrts, decay_rest_frame)
     class(process_t), intent(inout) :: process
     type(beam_structure_t), intent(in) :: beam_structure
     real(default), intent(in) :: sqrts
     logical, intent(in), optional :: decay_rest_frame
     integer :: n_in
     logical :: applies
     n_in = process%get_n_in ()
     call beam_structure%check_against_n_in (process%get_n_in (), applies)
     if (applies) then
        call process%beam_config%init_beam_structure &
             (beam_structure, sqrts, process%get_model_ptr (), decay_rest_frame)
     else if (n_in == 2) then
        call process%setup_beams_sqrts (sqrts, beam_structure)
     else
        call process%setup_beams_decay (decay_rest_frame, beam_structure)
     end if
   end subroutine process_setup_beams_beam_structure
 
 @ %def process_setup_beams_beam_structure
 @ Notify the user about beam setup.
 <<Process: process: TBP>>=
   procedure :: beams_startup_message => process_beams_startup_message
 <<Process: procedures>>=
   subroutine process_beams_startup_message (process, unit, beam_structure)
     class(process_t), intent(in) :: process
     integer, intent(in), optional :: unit
     type(beam_structure_t), intent(in), optional :: beam_structure
     call process%beam_config%startup_message (unit, beam_structure)
   end subroutine process_beams_startup_message
 
 @ %def process_beams_startup_message
 @ We complete the kinematics configuration after the beam setup, but before we
 configure the chain of structure functions.  The reason is that we need the
 total energy [[sqrts]] for the kinematics, but the structure-function setup
 requires the number of channels, which depends on the kinematics
 configuration.  For instance, the kinematics module may return the need for
 parameterizing an s-channel resonance.
 <<Process: process: TBP>>=
   procedure :: configure_phs => process_configure_phs
 <<Process: procedures>>=
   subroutine process_configure_phs (process, rebuild, ignore_mismatch, &
      combined_integration, subdir)
     class(process_t), intent(inout) :: process
     logical, intent(in), optional :: rebuild
     logical, intent(in), optional :: ignore_mismatch
     logical, intent(in), optional :: combined_integration
     type(string_t), intent(in), optional :: subdir
     real(default) :: sqrts
     integer :: i, i_born
     class(phs_config_t), pointer :: phs_config_born
     sqrts = process%get_sqrts ()
     do i = 1, process%meta%n_components
        associate (component => process%component(i))
          if (component%active) then
             select type (pcm => process%pcm)
             type is (pcm_default_t)
                call component%configure_phs (sqrts, process%beam_config, &
                     rebuild, ignore_mismatch, subdir)
             class is (pcm_nlo_t)
                select case (component%config%get_nlo_type ())
                case (BORN, NLO_VIRTUAL, NLO_SUBTRACTION)
                   call component%configure_phs (sqrts, process%beam_config, &
                        rebuild, ignore_mismatch, subdir)
                   call check_and_extend_phs (component)
                case (NLO_REAL, NLO_MISMATCH, NLO_DGLAP)
                   i_born = component%config%get_associated_born ()
                   if (component%component_type /= COMP_REAL_FIN) &
                        call check_and_extend_phs (component)
                   call process%component(i_born)%get_phs_config (phs_config_born)
                   select type (config => component%phs_config)
                   type is (phs_fks_config_t)
                      select type (phs_config_born)
                      type is (phs_wood_config_t)
                         config%md5sum_born_config = phs_config_born%md5sum_phs_config
                         call config%set_born_config (phs_config_born)
                         call config%set_mode (component%config%get_nlo_type ())
                      end select
                   end select
                   call component%configure_phs (sqrts, &
                        process%beam_config, rebuild, ignore_mismatch, subdir)
                end select
             class default
                call msg_bug ("process_configure_phs: unsupported PCM type")
             end select
          end if
        end associate
     end do
   contains
     subroutine check_and_extend_phs (component)
       type(process_component_t), intent(inout) :: component
       logical :: requires_dglap_random_number
       if (combined_integration) then
          requires_dglap_random_number = any (process%component%get_nlo_type () == NLO_DGLAP)
          select type (phs_config => component%phs_config)
          class is (phs_wood_config_t)
             if (requires_dglap_random_number) then
                call phs_config%set_extension_mode (EXTENSION_DGLAP)
             else
                call phs_config%set_extension_mode (EXTENSION_DEFAULT)
             end if
             call phs_config%increase_n_par ()
          end select
       end if
     end subroutine check_and_extend_phs
   end subroutine process_configure_phs
 
 @ %def process_configure_phs
 @
 <<Process: process: TBP>>=
   procedure :: print_phs_startup_message => process_print_phs_startup_message
 <<Process: procedures>>=
   subroutine process_print_phs_startup_message (process)
     class(process_t), intent(in) :: process
     integer :: i_component
     do i_component = 1, process%meta%n_components
        associate (component => process%component(i_component))
           if (component%active) then
              call component%phs_config%startup_message ()
           end if
        end associate
     end do
   end subroutine process_print_phs_startup_message
 
 @ %def process_print_phs_startup_message
 @ Insert the structure-function configuration data.  First allocate the
 storage, then insert data one by one.  The third procedure declares a
 mapping (of the MC input parameters) for a specific channel and
 structure-function combination.
 
 We take the number of channels from the corresponding entry in the
 [[config_data]] section.
 
 Otherwise, these a simple wrapper routines.  The extra level in the
 call tree may allow for simple addressing of multiple concurrent beam
 configurations, not implemented currently.
 
 If we do not want structure functions, we simply do not call those procedures.
 <<Process: process: TBP>>=
   procedure :: init_sf_chain => process_init_sf_chain
   generic :: set_sf_channel => set_sf_channel_single
   procedure :: set_sf_channel_single => process_set_sf_channel
   generic :: set_sf_channel => set_sf_channel_array
   procedure :: set_sf_channel_array => process_set_sf_channel_array
 <<Process: procedures>>=
   subroutine process_init_sf_chain (process, sf_config, sf_trace_file)
     class(process_t), intent(inout) :: process
     type(sf_config_t), dimension(:), intent(in) :: sf_config
     type(string_t), intent(in), optional :: sf_trace_file
     type(string_t) :: file
     if (present (sf_trace_file)) then
        if (sf_trace_file /= "") then
           file = sf_trace_file
        else
           file = process%get_id () // "_sftrace.dat"
        end if
        call process%beam_config%init_sf_chain (sf_config, file)
     else
        call process%beam_config%init_sf_chain (sf_config)
     end if
   end subroutine process_init_sf_chain
 
   subroutine process_set_sf_channel (process, c, sf_channel)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: c
     type(sf_channel_t), intent(in) :: sf_channel
     call process%beam_config%set_sf_channel (c, sf_channel)
   end subroutine process_set_sf_channel
 
   subroutine process_set_sf_channel_array (process, sf_channel)
     class(process_t), intent(inout) :: process
     type(sf_channel_t), dimension(:), intent(in) :: sf_channel
     integer :: c
     call process%beam_config%allocate_sf_channels (size (sf_channel))
     do c = 1, size (sf_channel)
        call process%beam_config%set_sf_channel (c, sf_channel(c))
     end do
   end subroutine process_set_sf_channel_array
 
 @ %def process_init_sf_chain
 @ %def process_set_sf_channel
 @ Notify about the structure-function setup.
 <<Process: process: TBP>>=
   procedure :: sf_startup_message => process_sf_startup_message
 <<Process: procedures>>=
   subroutine process_sf_startup_message (process, sf_string, unit)
     class(process_t), intent(in) :: process
     type(string_t), intent(in) :: sf_string
     integer, intent(in), optional :: unit
     call process%beam_config%sf_startup_message (sf_string, unit)
   end subroutine process_sf_startup_message
 
 @ %def process_sf_startup_message
 @ As soon as both the kinematics configuration and the
 structure-function setup are complete, we match parameterizations
 (channels) for both.  The matching entries are (re)set in the
 [[component]] phase-space configuration, while the structure-function
 configuration is left intact.
 <<Process: process: TBP>>=
   procedure :: collect_channels => process_collect_channels
 <<Process: procedures>>=
   subroutine process_collect_channels (process, coll)
     class(process_t), intent(inout) :: process
     type(phs_channel_collection_t), intent(inout) :: coll
     integer :: i
     do i = 1, process%meta%n_components
        associate (component => process%component(i))
          if (component%active) &
             call component%collect_channels (coll)
        end associate
     end do
   end subroutine process_collect_channels
 
 @ %def process_collect_channels
 @ Independently, we should be able to check if any component doesn't
 contain phase-space parameters.  Such a process can only be integrated
 if there are structure functions.
 <<Process: process: TBP>>=
   procedure :: contains_trivial_component => process_contains_trivial_component
 <<Process: procedures>>=
   function process_contains_trivial_component (process) result (flag)
     class(process_t), intent(in) :: process
     logical :: flag
     integer :: i
     flag = .true.
     do i = 1, process%meta%n_components
        associate (component => process%component(i))
          if (component%active) then
             if (component%get_n_phs_par () == 0)  return
          end if
        end associate
     end do
     flag = .false.
   end function process_contains_trivial_component
 
 @ %def process_contains_trivial_component
 @
 <<Process: process: TBP>>=
   procedure :: get_master_component => process_get_master_component
 <<Process: procedures>>=
   function process_get_master_component (process, i_mci) result (i_component)
      integer :: i_component
      class(process_t), intent(in) :: process
      integer, intent(in) :: i_mci
      integer :: i
      i_component = 0
      do i = 1, size (process%component)
         if (process%component(i)%i_mci == i_mci) then
            i_component = i
            return
         end if
      end do
   end function process_get_master_component
 
 
 @ %def process_get_master_component
 @ Determine the MC parameter set structure and the MCI configuration for each
 process component.  We need data from the structure-function and phase-space
 setup, so those should be complete before this is called.  We also
 make a random-number generator instance for each MCI group.
 <<Process: process: TBP>>=
   procedure :: setup_mci => process_setup_mci
 <<Process: procedures>>=
   subroutine process_setup_mci (process, combined_integration)
     class(process_t), intent(inout) :: process
     logical, intent(in), optional :: combined_integration
     integer :: n_mci, i_mci
     integer :: i
     logical :: uses_real_partition
     call msg_debug (D_PROCESS_INTEGRATION, "process_setup_mci")
     n_mci = 0
     do i = 1, process%meta%n_components
        associate (component => process%component(i))
           if (component%needs_mci_entry (combined_integration) .and. &
               component%config%get_nlo_type () /= NLO_SUBTRACTION) then
             n_mci = n_mci + 1
             component%i_mci = n_mci
          end if
          call msg_debug (D_PROCESS_INTEGRATION, &
               "component%component_type", component%component_type)
        end associate
     end do
     process%config%n_mci = n_mci
     if (.not. allocated (process%config%rng_factory)) &
          call msg_bug ("Process setup: rng factory not allocated")
     allocate (process%mci_entry (n_mci))
     i_mci = 0
     uses_real_partition = &
         any (process%component%component_type == COMP_REAL_FIN)
     call msg_debug (D_PROCESS_INTEGRATION, "uses_real_partition", &
          uses_real_partition)
     do i = 1, process%meta%n_components
        associate (component => process%component(i))
           if (component%needs_mci_entry (combined_integration) .and. &
               component%config%get_nlo_type () /= NLO_SUBTRACTION) then
             i_mci = i_mci + 1
             associate (mci_entry => process%mci_entry(i_mci))
               call mci_entry%set_combined_integration (combined_integration)
               if (uses_real_partition) then
                  if (component%component_type == COMP_REAL_FIN) then
                     mci_entry%real_partition_type = REAL_FINITE
                  else
                     mci_entry%real_partition_type = REAL_SINGULAR
                  end if
               end if
 
               call mci_entry%init (process%meta%type, &
                    i_mci, i, component, process%beam_config%n_sfpar, &
                    process%config%rng_factory)
             end associate
           end if
        end associate
     end do
     do i_mci = 1, size (process%mci_entry)
        call process%mci_entry(i_mci)%set_parameters (process%meta%var_list)
     end do
   end subroutine process_setup_mci
 
 @ %def process_setup_mci
 @ Set cuts.  This is a parse node, namely the right-hand side of the [[cut]]
 assignment.  When creating an instance, we compile this into an evaluation
 tree.  The parse node may be null.
 <<Process: process: TBP>>=
   procedure :: set_cuts => process_set_cuts
 <<Process: procedures>>=
   subroutine process_set_cuts (process, ef_cuts)
     class(process_t), intent(inout) :: process
     class(expr_factory_t), intent(in) :: ef_cuts
     allocate (process%config%ef_cuts, source = ef_cuts)
   end subroutine process_set_cuts
 
 @ %def process_set_cuts
 @ Analogously for the other expressions.
 <<Process: process: TBP>>=
   procedure :: set_scale => process_set_scale
   procedure :: set_fac_scale => process_set_fac_scale
   procedure :: set_ren_scale => process_set_ren_scale
   procedure :: set_weight => process_set_weight
 <<Process: procedures>>=
   subroutine process_set_scale (process, ef_scale)
     class(process_t), intent(inout) :: process
     class(expr_factory_t), intent(in) :: ef_scale
     allocate (process%config%ef_scale, source = ef_scale)
   end subroutine process_set_scale
 
   subroutine process_set_fac_scale (process, ef_fac_scale)
     class(process_t), intent(inout) :: process
     class(expr_factory_t), intent(in) :: ef_fac_scale
     allocate (process%config%ef_fac_scale, source = ef_fac_scale)
   end subroutine process_set_fac_scale
 
   subroutine process_set_ren_scale (process, ef_ren_scale)
     class(process_t), intent(inout) :: process
     class(expr_factory_t), intent(in) :: ef_ren_scale
     allocate (process%config%ef_ren_scale, source = ef_ren_scale)
   end subroutine process_set_ren_scale
 
   subroutine process_set_weight (process, ef_weight)
     class(process_t), intent(inout) :: process
     class(expr_factory_t), intent(in) :: ef_weight
     allocate (process%config%ef_weight, source = ef_weight)
   end subroutine process_set_weight
 
 @ %def process_set_scale
 @ %def process_set_fac_scale
 @ %def process_set_ren_scale
 @ %def process_set_weight
 @
 \subsubsection{MD5 sum}
 The MD5 sum of the process object should reflect the state completely,
 including integration results.  It is used for checking the integrity
 of event files.  This global checksum includes checksums for the
 various parts.  In particular, the MCI object receives a checksum that
 includes the configuration of all configuration parts relevant for an
 individual integration.  This checksum is used for checking the
 integrity of integration grids.
 
 We do not need MD5 sums for the process terms, since these are
 generated from the component definitions.
 <<Process: process: TBP>>=
   procedure :: compute_md5sum => process_compute_md5sum
 <<Process: procedures>>=
   subroutine process_compute_md5sum (process)
     class(process_t), intent(inout) :: process
     integer :: i
     call process%config%compute_md5sum ()
     do i = 1, process%config%n_components
        associate (component => process%component(i))
          if (component%active) then
             call component%compute_md5sum ()
          end if
        end associate
     end do
     call process%beam_config%compute_md5sum ()
     do i = 1, process%config%n_mci
        call process%mci_entry(i)%compute_md5sum &
             (process%config, process%component, process%beam_config)
     end do
   end subroutine process_compute_md5sum
 
 @ %def process_compute_md5sum
 @
 <<Process: process: TBP>>=
   procedure :: sampler_test => process_sampler_test
 <<Process: procedures>>=
   subroutine process_sampler_test (process, sampler, n_calls, i_mci)
     class(process_t), intent(inout) :: process
     class(mci_sampler_t), intent(inout) :: sampler
     integer, intent(in) :: n_calls, i_mci
     call process%mci_entry(i_mci)%sampler_test (sampler, n_calls)
   end subroutine process_sampler_test
 
 @ %def process_sampler_test
 @ The finalizer should be called after all integration passes have been
 completed.  It will, for instance, write a summary of the integration
 results.
 
 [[integrate_dummy]] does a ``dummy'' integration in the sense that
 nothing is done but just empty integration results appended.
 <<Process: process: TBP>>=
   procedure :: final_integration => process_final_integration
   procedure :: integrate_dummy => process_integrate_dummy
 <<Process: procedures>>=
   subroutine process_final_integration (process, i_mci)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_mci
     call process%mci_entry(i_mci)%final_integration ()
   end subroutine process_final_integration
 
   subroutine process_integrate_dummy (process)
     class(process_t), intent(inout) :: process
     type(integration_results_t) :: results
     integer :: u_log
     u_log = logfile_unit ()
     call results%init (process%meta%type)
     call results%display_init (screen = .true., unit = u_log)
     call results%new_pass ()
     call results%record (1, 0, 0._default, 0._default, 0._default)
     call results%display_final ()
   end subroutine process_integrate_dummy
 
 @ %def process_final_integration
 @ %def process_integrate_dummy
 @
 <<Process: process: TBP>>=
   procedure :: integrate => process_integrate
 <<Process: procedures>>=
   subroutine process_integrate (process, i_mci, mci_work, &
      mci_sampler, n_it, n_calls, adapt_grids, adapt_weights, final, &
      pacify, nlo_type)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_mci
     type(mci_work_t), intent(inout) :: mci_work
     class(mci_sampler_t), intent(inout) :: mci_sampler
     integer, intent(in) :: n_it, n_calls
     logical, intent(in), optional :: adapt_grids, adapt_weights
     logical, intent(in), optional :: final
     logical, intent(in), optional :: pacify
     integer, intent(in), optional :: nlo_type
     associate (mci_entry => process%mci_entry(i_mci))
        call mci_entry%integrate (mci_work%mci, mci_sampler, n_it, n_calls, &
             adapt_grids, adapt_weights, final, pacify, &
             nlo_type = nlo_type)
        call mci_entry%results%display_pass (pacify)
     end associate
   end subroutine process_integrate
 
 @ %def process_integrate
 @
 <<Process: process: TBP>>=
   procedure :: generate_weighted_event => process_generate_weighted_event
 <<Process: procedures>>=
   subroutine process_generate_weighted_event (process, i_mci, mci_work, &
      mci_sampler, keep_failed_events)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_mci
     type(mci_work_t), intent(inout) :: mci_work
     class(mci_sampler_t), intent(inout) :: mci_sampler
     logical, intent(in) :: keep_failed_events
     associate (mci_entry => process%mci_entry(i_mci))
        call mci_entry%generate_weighted_event (mci_work%mci, &
             mci_sampler, keep_failed_events)
     end associate
   end subroutine process_generate_weighted_event
 
 @ %def process_generate_weighted_event
 <<Process: process: TBP>>=
   procedure :: generate_unweighted_event => process_generate_unweighted_event
 <<Process: procedures>>=
   subroutine process_generate_unweighted_event (process, i_mci, &
      mci_work, mci_sampler)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_mci
     type(mci_work_t), intent(inout) :: mci_work
     class(mci_sampler_t), intent(inout) :: mci_sampler
     associate (mci_entry => process%mci_entry(i_mci))
        call mci_entry%generate_unweighted_event &
           (mci_work%mci, mci_sampler)
     end associate
   end subroutine process_generate_unweighted_event
 
 @ %def process_generate_unweighted_event
 @ Display the final results for the sum of all components.  (This is useful,
 obviously, only if there is more than one component.)
 <<Process: process: TBP>>=
   procedure :: display_summed_results => process_display_summed_results
 <<Process: procedures>>=
   subroutine process_display_summed_results (process, pacify)
     class(process_t), intent(inout) :: process
     logical, intent(in) :: pacify
     type(integration_results_t) :: results
     integer :: u_log
     u_log = logfile_unit ()
     call results%init (process%meta%type)
     call results%display_init (screen = .true., unit = u_log)
     call results%new_pass ()
     call results%record (1, 0, &
          process%get_integral (), &
          process%get_error (), &
          process%get_efficiency (), suppress = pacify)
     select type (pcm => process%pcm)
     class is (pcm_nlo_t)
        !!! Check that Born integral is there
        if (process%component_can_be_integrated (1)) then
           call results%record_correction (process%get_correction (), &
                process%get_correction_error ())
        end if
     end select
     call results%display_final ()
   end subroutine process_display_summed_results
 
 @ %def process_display_summed_results
 @ Run LaTeX/Metapost to generate a ps/pdf file for the integration
 history.  We (re)write the driver file -- just in case it has been
 missed before -- then we compile it.
 <<Process: process: TBP>>=
   procedure :: display_integration_history => &
        process_display_integration_history
 <<Process: procedures>>=
   subroutine process_display_integration_history &
        (process, i_mci, filename, os_data, eff_reset)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_mci
     type(string_t), intent(in) :: filename
     type(os_data_t), intent(in) :: os_data
     logical, intent(in), optional :: eff_reset
     call integration_results_write_driver &
          (process%mci_entry(i_mci)%results, filename, eff_reset)
     call integration_results_compile_driver &
          (process%mci_entry(i_mci)%results, filename, os_data)
   end subroutine process_display_integration_history
 
 @ %def subroutine process_display_integration_history
 @ Write a complete logfile (with hardcoded name based on the process ID).
 We do not write internal data.
 <<Process: process: TBP>>=
   procedure :: write_logfile => process_write_logfile
 <<Process: procedures>>=
   subroutine process_write_logfile (process, i_mci, filename)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_mci
     type(string_t), intent(in) :: filename
     type(time_t) :: time
     integer :: unit, u
     unit = free_unit ()
     open (unit = unit, file = char (filename), action = "write", &
           status = "replace")
     u = given_output_unit (unit)
     write (u, "(A)")  repeat ("#", 79)
     call process%meta%write (u, .false., .false.)
     write (u, "(A)")  repeat ("#", 79)
     write (u, "(3x,A,ES17.10)")  "Integral   = ", &
          process%mci_entry(i_mci)%get_integral ()
     write (u, "(3x,A,ES17.10)")  "Error      = ", &
          process%mci_entry(i_mci)%get_error ()
     write (u, "(3x,A,ES17.10)")  "Accuracy   = ", &
          process%mci_entry(i_mci)%get_accuracy ()
     write (u, "(3x,A,ES17.10)")  "Chi2       = ", &
          process%mci_entry(i_mci)%get_chi2 ()
     write (u, "(3x,A,ES17.10)")  "Efficiency = ", &
          process%mci_entry(i_mci)%get_efficiency ()
     call process%mci_entry(i_mci)%get_time (time, 10000)
     if (time%is_known ()) then
        write (u, "(3x,A,1x,A)")  "T(10k evt) = ", char (time%to_string_dhms ())
     else
        write (u, "(3x,A)")  "T(10k evt) =  [undefined]"
     end if
     call process%mci_entry(i_mci)%results%write (u)
     write (u, "(A)")  repeat ("#", 79)
     call process%mci_entry(i_mci)%results%write_chain_weights (u)
     write (u, "(A)")  repeat ("#", 79)
     call process%mci_entry(i_mci)%counter%write (u)
     write (u, "(A)")  repeat ("#", 79)
     call process%mci_entry(i_mci)%mci%write_log_entry (u)
     write (u, "(A)")  repeat ("#", 79)
     call process%beam_config%data%write (u)
     write (u, "(A)")  repeat ("#", 79)
     if (allocated (process%config%ef_cuts)) then
        write (u, "(3x,A)") "Cut expression:"
        call process%config%ef_cuts%write (u)
     else
        write (u, "(3x,A)") "No cuts used."
     end if
     call write_separator (u)
     if (allocated (process%config%ef_scale)) then
        write (u, "(3x,A)") "Scale expression:"
        call process%config%ef_scale%write (u)
     else
        write (u, "(3x,A)") "No scale expression was given."
     end if
     call write_separator (u)
     if (allocated (process%config%ef_fac_scale)) then
        write (u, "(3x,A)") "Factorization scale expression:"
        call process%config%ef_fac_scale%write (u)
     else
        write (u, "(3x,A)") "No factorization scale expression was given."
     end if
     call write_separator (u)
     if (allocated (process%config%ef_ren_scale)) then
        write (u, "(3x,A)") "Renormalization scale expression:"
        call process%config%ef_ren_scale%write (u)
     else
        write (u, "(3x,A)") "No renormalization scale expression was given."
     end if
     call write_separator (u)
     if (allocated (process%config%ef_weight)) then
        call write_separator (u)
        write (u, "(3x,A)") "Weight expression:"
        call process%config%ef_weight%write (u)
     else
        write (u, "(3x,A)") "No weight expression was given."
     end if
     write (u, "(A)")  repeat ("#", 79)
     write (u, "(1x,A)") "Summary of quantum-number states:"
     write (u, "(1x,A)")  " + sign: allowed and contributing"
     write (u, "(1x,A)")  " no +  : switched off at runtime"
     call process%write_state_summary (u)
     write (u, "(A)")  repeat ("#", 79)
     write (u, "(A)")  "Variable list:"
     call var_list_write (process%meta%var_list, u)
     write (u, "(A)")  repeat ("#", 79)
     close (u)
   end subroutine process_write_logfile
 
 @ %def process_write_logfile
 @ Display the quantum-number combinations of the process components, and their
 current status (allowed or switched off).
 <<Process: process: TBP>>=
   procedure :: write_state_summary => process_write_state_summary
 <<Process: procedures>>=
   subroutine process_write_state_summary (process, unit)
     class(process_t), intent(in) :: process
     integer, intent(in), optional :: unit
     integer :: i, i_component, u
     u = given_output_unit (unit)
     do i = 1, size (process%term)
        call write_separator (u)
        i_component = process%term(i)%i_component
        if (i_component /= 0) then
           call process%term(i)%write_state_summary &
                (process%get_core_term(i), unit)
        end if
     end do
   end subroutine process_write_state_summary
 
 @ %def process_write_state_summary
 @ Prepare event generation for the specified MCI entry.  This implies, in
 particular, checking the phase-space file.
 <<Process: process: TBP>>=
   procedure :: prepare_simulation => process_prepare_simulation
 <<Process: procedures>>=
   subroutine process_prepare_simulation (process, i_mci)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_mci
     call process%mci_entry(i_mci)%prepare_simulation ()
   end subroutine process_prepare_simulation
 
 @ %def process_prepare_simulation
 @
 \subsubsection{Retrieve process data}
 Tell whether integral (and error) are known.
 <<Process: process: TBP>>=
   generic :: has_integral => has_integral_tot, has_integral_mci
   procedure :: has_integral_tot => process_has_integral_tot
   procedure :: has_integral_mci => process_has_integral_mci
 <<Process: procedures>>=
   function process_has_integral_mci (process, i_mci) result (flag)
     logical :: flag
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_mci
     if (allocated (process%mci_entry)) then
        flag = process%mci_entry(i_mci)%has_integral ()
     else
        flag = .false.
     end if
   end function process_has_integral_mci
 
   function process_has_integral_tot (process) result (flag)
     logical :: flag
     class(process_t), intent(in) :: process
     integer :: i, j, i_component
     if (allocated (process%mci_entry)) then
        flag = .true.
        do i = 1, size (process%mci_entry)
           do j = 1, size (process%mci_entry(i)%i_component)
              i_component = process%mci_entry(i)%i_component(j)
              if (process%component_can_be_integrated (i_component)) &
                 flag = flag .and. process%mci_entry(i)%has_integral ()
           end do
        end do
     else
        flag = .false.
     end if
   end function process_has_integral_tot
 
 @ %def process_has_integral
 @
 Return the current integral and error obtained by the integrator [[i_mci]].
 <<Process: process: TBP>>=
   generic :: get_integral => get_integral_tot, get_integral_mci
   generic :: get_error => get_error_tot, get_error_mci
   generic :: get_efficiency => get_efficiency_tot, get_efficiency_mci
   procedure :: get_integral_tot => process_get_integral_tot
   procedure :: get_integral_mci => process_get_integral_mci
   procedure :: get_error_tot => process_get_error_tot
   procedure :: get_error_mci => process_get_error_mci
   procedure :: get_efficiency_tot => process_get_efficiency_tot
   procedure :: get_efficiency_mci => process_get_efficiency_mci
 <<Process: procedures>>=
   function process_get_integral_mci (process, i_mci) result (integral)
     real(default) :: integral
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_mci
     integral = process%mci_entry(i_mci)%get_integral ()
   end function process_get_integral_mci
 
   function process_get_error_mci (process, i_mci) result (error)
     real(default) :: error
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_mci
     error = process%mci_entry(i_mci)%get_error ()
   end function process_get_error_mci
 
   function process_get_efficiency_mci (process, i_mci) result (efficiency)
     real(default) :: efficiency
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_mci
     efficiency = process%mci_entry(i_mci)%get_efficiency ()
   end function process_get_efficiency_mci
 
   function process_get_integral_tot (process) result (integral)
     real(default) :: integral
     class(process_t), intent(in) :: process
     integer :: i, j, i_component
     integral = zero
     if (allocated (process%mci_entry)) then
        do i = 1, size (process%mci_entry)
           do j = 1, size (process%mci_entry(i)%i_component)
              i_component = process%mci_entry(i)%i_component(j)
              if (process%component_can_be_integrated(i_component)) &
                   integral = integral + process%mci_entry(i)%get_integral ()
           end do
        end do
     end if
   end function process_get_integral_tot
 
   function process_get_error_tot (process) result (error)
     real(default) :: variance
     class(process_t), intent(in) :: process
     real(default) :: error
     integer :: i, j, i_component
     variance = zero
     if (allocated (process%mci_entry)) then
        do i = 1, size (process%mci_entry)
           do j = 1, size (process%mci_entry(i)%i_component)
              i_component = process%mci_entry(i)%i_component(j)
              if (process%component_can_be_integrated(i_component)) &
                   variance = variance + process%mci_entry(i)%get_error () ** 2
           end do
        end do
     end if
     error = sqrt (variance)
   end function process_get_error_tot
 
   function process_get_efficiency_tot (process) result (efficiency)
     real(default) :: efficiency
     class(process_t), intent(in) :: process
     real(default) :: den, eff, int
     integer :: i, j, i_component
     den = zero
     if (allocated (process%mci_entry)) then
        do i = 1, size (process%mci_entry)
           do j = 1, size (process%mci_entry(i)%i_component)
              i_component = process%mci_entry(i)%i_component(j)
              if (process%component_can_be_integrated(i_component)) then
                 int = process%get_integral (i)
                 if (int > 0) then
                    eff = process%mci_entry(i)%get_efficiency ()
                    if (eff > 0) then
                       den = den + int / eff
                    else
                       efficiency = 0
                       return
                    end if
                 end if
              end if
           end do
        end do
     end if
     if (den > 0) then
        efficiency = process%get_integral () / den
     else
        efficiency = 0
     end if
   end function process_get_efficiency_tot
 
 @ %def process_get_integral process_get_efficiency
 @ Let us call the ratio of the LO and the NLO result $\iota = I_{LO} / I_{NLO}$. Then
 usual error propagation gives
 \begin{equation*}
   \sigma_{\iota}^2 = \left(\frac{\partial \iota}{\partial I_{LO}}\right)^2 \sigma_{I_{LO}}^2
                    + \left(\frac{\partial \iota}{\partial I_{NLO}}\right)^2 \sigma_{I_{NLO}}^2
                    = \frac{I_{NLO}^2\sigma_{I_{LO}}^2}{I_{LO}^4} + \frac{\sigma_{I_{NLO}}^2}{I_{LO}^2}.
 \end{equation*}
 <<Process: process: TBP>>=
   procedure :: get_correction => process_get_correction
   procedure :: get_correction_error => process_get_correction_error
 <<Process: procedures>>=
   function process_get_correction (process) result (ratio)
     real(default) :: ratio
     class(process_t), intent(in) :: process
     integer :: i_mci
     real(default) :: int_born, int_nlo
     int_nlo = zero
     int_born = process%mci_entry(1)%get_integral ()
     do i_mci = 2, size (process%mci_entry)
        if (process%component_can_be_integrated (i_mci)) &
           int_nlo = int_nlo + process%mci_entry(i_mci)%get_integral ()
     end do
     ratio = int_nlo / int_born * 100
   end function process_get_correction
 
   function process_get_correction_error (process) result (error)
     real(default) :: error
     class(process_t), intent(in) :: process
     real(default) :: int_born, sum_int_nlo
     real(default) :: err_born, err2
     integer :: i_mci
     sum_int_nlo = zero; err2 = zero
     int_born = process%mci_entry(1)%get_integral ()
     err_born = process%mci_entry(1)%get_error ()
     do i_mci = 2, size (process%mci_entry)
        if (process%component_can_be_integrated (i_mci)) then
           sum_int_nlo = sum_int_nlo + process%mci_entry(i_mci)%get_integral ()
           err2 = err2 + process%mci_entry(i_mci)%get_error()**2
        end if
     end do
     error = sqrt (err2 / int_born**2 + sum_int_nlo**2 * err_born**2 / int_born**4) * 100
   end function process_get_correction_error
 
 @ %def process_get_correction process_get_correction_error
 @
 <<Process: process: TBP>>=
   procedure :: lab_is_cm_frame => process_lab_is_cm_frame
 <<Process: procedures>>=
   pure function process_lab_is_cm_frame (process) result (cm_frame)
     logical :: cm_frame
     class(process_t), intent(in) :: process
     cm_frame = process%beam_config%lab_is_cm_frame
   end function process_lab_is_cm_frame
 
 @ %def process_lab_is_cm_frame
 @
 <<Process: process: TBP>>=
   procedure :: get_component_ptr => process_get_component_ptr
 <<Process: procedures>>=
   function process_get_component_ptr (process, i) result (component)
     type(process_component_t), pointer :: component
     class(process_t), intent(in), target :: process
     integer, intent(in) :: i
     component => process%component(i)
   end function process_get_component_ptr
 
 @ %def process_get_component_ptr
 @
 <<Process: process: TBP>>=
   procedure :: get_qcd_ptr => process_get_qcd_ptr
 <<Process: procedures>>=
   function process_get_qcd_ptr (process) result (qcd)
     type(qcd_t), pointer :: qcd
     class(process_t), intent(in), target :: process
     qcd => process%config%qcd
   end function process_get_qcd_ptr
 
 @ %def process_get_qcd_ptr
 @
 <<Process: process: TBP>>=
   generic :: get_component_type => get_component_type_single
   procedure :: get_component_type_single => process_get_component_type_single
 <<Process: procedures>>=
   elemental function process_get_component_type_single &
      (process, i_component) result (comp_type)
     integer :: comp_type
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_component
     comp_type = process%component(i_component)%component_type
   end function process_get_component_type_single
 
 @ %def process_get_component_type_single
 @
 <<Process: process: TBP>>=
   generic :: get_component_type => get_component_type_all
   procedure :: get_component_type_all => process_get_component_type_all
 <<Process: procedures>>=
   function process_get_component_type_all &
      (process) result (comp_type)
     integer, dimension(:), allocatable :: comp_type
     class(process_t), intent(in) :: process
     allocate (comp_type (size (process%component)))
     comp_type = process%component%component_type
   end function process_get_component_type_all
 
 @ %def process_get_component_type_all
 @
 <<Process: process: TBP>>=
   procedure :: get_component_i_terms => process_get_component_i_terms
 <<Process: procedures>>=
   function process_get_component_i_terms (process, i_component) result (i_term)
      integer, dimension(:), allocatable :: i_term
      class(process_t), intent(in) :: process
      integer, intent(in) :: i_component
      allocate (i_term (size (process%component(i_component)%i_term)))
      i_term = process%component(i_component)%i_term
   end function process_get_component_i_terms
 
 @ %def process_get_component_i_terms
 @
 <<Process: process: TBP>>=
   procedure :: get_n_allowed_born => process_get_n_allowed_born
 <<Process: procedures>>=
   function process_get_n_allowed_born (process, i_born) result (n_born)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_born
     integer :: n_born
     n_born = process%term(i_born)%n_allowed
   end function process_get_n_allowed_born
 
 @ %def process_get_n_allowed_born
 @ Workaround getter. Would be better to remove this.
 <<Process: process: TBP>>=
   procedure :: get_pcm_ptr => process_get_pcm_ptr
 <<Process: procedures>>=
   function process_get_pcm_ptr (process) result (pcm)
     class(pcm_t), pointer :: pcm
     class(process_t), intent(in), target :: process
     pcm => process%pcm
   end function process_get_pcm_ptr
 
 @ %def process_get_pcm_ptr
 <<Process: process: TBP>>=
   generic :: component_can_be_integrated => component_can_be_integrated_single
   generic :: component_can_be_integrated => component_can_be_integrated_all
   procedure :: component_can_be_integrated_single => process_component_can_be_integrated_single
 <<Process: procedures>>=
   function process_component_can_be_integrated_single (process, i_component) &
            result (active)
     logical :: active
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_component
     logical :: combined_integration
     select type (pcm => process%pcm)
     type is (pcm_nlo_t)
        combined_integration = pcm%settings%combined_integration
     class default
        combined_integration = .false.
     end select
     associate (component => process%component(i_component))
        active = component%can_be_integrated ()
        if (combined_integration) &
             active = active .and. component%component_type <= COMP_MASTER
     end associate
   end function process_component_can_be_integrated_single
 
 @ %def process_component_can_be_integrated_single
 @
 <<Process: process: TBP>>=
   procedure :: component_can_be_integrated_all => process_component_can_be_integrated_all
 <<Process: procedures>>=
   function process_component_can_be_integrated_all (process) result (val)
     logical, dimension(:), allocatable :: val
     class(process_t), intent(in) :: process
     integer :: i
     allocate (val (size (process%component)))
     do i = 1, size (process%component)
        val(i) = process%component_can_be_integrated (i)
     end do
   end function process_component_can_be_integrated_all
 
 @ %def process_component_can_be_integrated_all
 @
 <<Process: process: TBP>>=
   procedure :: reset_selected_cores => process_reset_selected_cores
 <<Process: procedures>>=
   pure subroutine process_reset_selected_cores (process)
     class(process_t), intent(inout) :: process
     process%component_selected = .false.
   end subroutine process_reset_selected_cores
 
 @ %def process_reset_selected_cores
 @
 <<Process: process: TBP>>=
   procedure :: select_components => process_select_components
 <<Process: procedures>>=
   pure subroutine process_select_components (process, indices)
     class(process_t), intent(inout) :: process
     integer, dimension(:), intent(in) :: indices
     process%component_selected(indices) = .true.
   end subroutine process_select_components
 
 @ %def process_select_components
 @
 <<Process: process: TBP>>=
   procedure :: component_is_selected => process_component_is_selected
 <<Process: procedures>>=
   pure function process_component_is_selected (process, index) result (val)
     logical :: val
     class(process_t), intent(in) :: process
     integer, intent(in) :: index
     val = process%component_selected(index)
   end function process_component_is_selected
 
 @ %def process_component_is_selected
 @
 <<Process: process: TBP>>=
   procedure :: get_coupling_powers => process_get_coupling_powers
 <<Process: procedures>>=
   pure subroutine process_get_coupling_powers (process, alpha_power, alphas_power)
     class(process_t), intent(in) :: process
     integer, intent(out) :: alpha_power, alphas_power
     call process%component(1)%config%get_coupling_powers (alpha_power, alphas_power)
   end subroutine process_get_coupling_powers
 
 @ %def process_get_coupling_powers
 @
 <<Process: process: TBP>>=
   procedure :: get_real_component => process_get_real_component
 <<Process: procedures>>=
   function process_get_real_component (process) result (i_real)
     integer :: i_real
     class(process_t), intent(in) :: process
     integer :: i_component
     type(process_component_def_t), pointer :: config => null ()
     i_real = 0
     do i_component = 1, size (process%component)
        config => process%get_component_def_ptr (i_component)
        if (config%get_nlo_type () == NLO_REAL) then
           i_real = i_component
           exit
        end if
     end do
   end function process_get_real_component
 
 @ %def process_get_real_component
 @
 <<Process: process: TBP>>=
   procedure :: extract_active_component_mci => process_extract_active_component_mci
 <<Process: procedures>>=
   function process_extract_active_component_mci (process) result (i_active)
     integer :: i_active
     class(process_t), intent(in) :: process
     integer :: i_mci, j, i_component, n_active
     call count_n_active ()
     if (n_active /= 1) i_active = 0
   contains
     subroutine count_n_active ()
        n_active = 0
        do i_mci = 1, size (process%mci_entry)
           associate (mci_entry => process%mci_entry(i_mci))
              do j = 1, size (mci_entry%i_component)
                 i_component = mci_entry%i_component(j)
                 associate (component => process%component (i_component))
                    if (component%can_be_integrated ()) then
                       i_active = i_mci
                       n_active = n_active + 1
                    end if
                 end associate
              end do
           end associate
        end do
     end subroutine count_n_active
   end function process_extract_active_component_mci
 
 @ %def process_extract_active_component_mci
 @
 <<Process: process: TBP>>=
   procedure :: needs_extra_code => process_needs_extra_code
 <<Process: procedures>>=
   function process_needs_extra_code (process, only_blha) result (val)
     logical :: val
     class(process_t), intent(in) :: process
     logical, intent(in), optional :: only_blha
     integer :: i
     logical :: skip_other
     type(process_component_def_t), pointer :: config => null ()
     val = .false.; skip_other = .false.
     if (present (only_blha)) skip_other = only_blha
     associate (cm => process%cm)
        do i = 1, cm%n_cores
           config => process%get_component_def_ptr &
                (cm%i_core_to_first_i_component(i))
           if (config%can_be_integrated () .or. cm%sub(i)) then
              select type (core => cm%cores(i)%core)
              type is (prc_recola_t)
                 if (skip_other) cycle
                 val = .true.
                 exit
              class is (prc_blha_t)
                 val = .true.
                 exit
              class is (prc_threshold_t)
                 if (skip_other) cycle
                 val = .true.
                 exit
              end select
           end if
        end do
     end associate
 
   end function process_needs_extra_code
 
 @ %def process_needs_extra_code
 @
 <<Process: process: TBP>>=
   procedure :: uses_real_partition => process_uses_real_partition
 <<Process: procedures>>=
   function process_uses_real_partition (process) result (val)
      logical :: val
      class(process_t), intent(in) :: process
      val = any (process%mci_entry%real_partition_type /= REAL_FULL)
   end function process_uses_real_partition
 
 @ %def process_uses_real_partition
 @ Return the MD5 sums that summarize the process component
 definitions.  These values should be independent of parameters, beam
 details, expressions, etc.  They can be used for checking the
 integrity of a process when reusing an old event file.
 <<Process: process: TBP>>=
   procedure :: get_md5sum_prc => process_get_md5sum_prc
 <<Process: procedures>>=
   function process_get_md5sum_prc (process, i_component) result (md5sum)
     character(32) :: md5sum
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_component
     if (process%component(i_component)%active) then
        md5sum = process%component(i_component)%config%get_md5sum ()
     else
        md5sum = ""
     end if
   end function process_get_md5sum_prc
 
 @ %def process_get_md5sum_prc
 @ Return the MD5 sums that summarize the state of the MCI integrators.
 These values should encode all process data, integration and phase
 space configuration, etc., and the integration results.  They can thus
 be used for checking the integrity of an event-generation setup when
 reusing an old event file.
 <<Process: process: TBP>>=
   procedure :: get_md5sum_mci => process_get_md5sum_mci
 <<Process: procedures>>=
   function process_get_md5sum_mci (process, i_mci) result (md5sum)
     character(32) :: md5sum
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_mci
     md5sum = process%mci_entry(i_mci)%get_md5sum ()
   end function process_get_md5sum_mci
 
 @ %def process_get_md5sum_mci
 @ Return the MD5 sum of the process configuration.  This should encode
 the process setup, data, and expressions, but no integration results.
 <<Process: process: TBP>>=
   procedure :: get_md5sum_cfg => process_get_md5sum_cfg
 <<Process: procedures>>=
   function process_get_md5sum_cfg (process) result (md5sum)
     character(32) :: md5sum
     class(process_t), intent(in) :: process
     md5sum = process%config%md5sum
   end function process_get_md5sum_cfg
 
 @ %def process_get_md5sum_cfg
 @ Initialize the [[i_core]]th core.
 <<Process: process: TBP>>=
   procedure :: init_cores => process_init_cores
 <<Process: procedures>>=
   subroutine process_init_cores (process)
     class(process_t), intent(inout) :: process
     integer :: i_core, i_component
     type(process_component_def_t), pointer :: config
     do i_core = 1, process%get_n_cores ()
        i_component = process%cm%i_core_to_first_i_component (i_core)
        config => process%meta%lib%get_component_def_ptr (process%meta%id, i_component)
        associate (core => process%cm%cores(i_core)%core)
           call core%init (config%get_core_def_ptr (), &
                process%meta%lib, process%meta%id, i_component)
        end associate
     end do
   end subroutine process_init_cores
 
 @ %def process_init_core
 @
 <<Process: process: TBP>>=
   procedure :: init_blha_cores => process_init_blha_cores
 <<Process: procedures>>=
   subroutine process_init_blha_cores (process, blha_template, var_list)
     class(process_t), intent(inout) :: process
     type(blha_template_t), intent(inout) :: blha_template
     type(var_list_t), intent(in), pointer :: var_list
     integer :: i_core, n_in, n_legs, n_flv, n_hel, f
     type(flavor_t) :: flv_in
     do i_core = 1, process%get_n_cores ()
        call fill_blha_template (process%get_nlo_type (i_core))
        select type (core => process%cm%cores(i_core)%core)
        class is (prc_blha_t)
           select type (pcm => process%pcm)
           type is (pcm_nlo_t)
              n_in = pcm%region_data%get_n_in ()
              if (process%cm%core_is_radiation(i_core)) then
                 n_legs = pcm%region_data%get_n_legs_real ()
                 n_flv = pcm%region_data%get_n_flv_real ()
              else
                 n_legs = pcm%region_data%get_n_legs_born ()
                 n_flv = pcm%region_data%get_n_flv_born ()
              end if
           class default
              n_in = core%data%n_in
              n_legs = core%data%get_n_tot ()
              n_flv = core%data%n_flv
           end select
           n_hel = 1
           if (blha_template%include_polarizations) then
              do f = 1, core%data%n_in
                 call flv_in%init (core%data%flv_state (f, 1), process%config%model)
                 n_hel = n_hel * flv_in%get_multiplicity ()
              end do
           end if
           call core%init_blha (blha_template, n_in, n_legs, n_flv, n_hel)
           call core%init_driver (process%config%os_data)
        end select
        call blha_template%reset ()
     end do
   contains
     function needs_entry (me_method) result (val)
       logical :: val
       type(string_t), intent(in) :: me_method
       val = char (me_method) == 'gosam' .or. char (me_method) == 'openloops'
     end function needs_entry
 
     subroutine fill_blha_template (nlo_type)
       integer, intent(in) :: nlo_type
       type(string_t) :: method, born_me_method, real_tree_me_method, &
            loop_me_method, correlation_me_method, dglap_me_method
       method = var_list%get_sval (var_str ("$method"))
       born_me_method = var_list%get_sval (var_str ("$born_me_method"))
       if (born_me_method == "")  born_me_method = method
       real_tree_me_method = var_list%get_sval (var_str ("$real_tree_me_method"))
       if (real_tree_me_method == "")  real_tree_me_method = method
       loop_me_method = var_list%get_sval (var_str ("$loop_me_method"))
       if (loop_me_method == "")  loop_me_method = method
       correlation_me_method = var_list%get_sval (var_str ("$correlation_me_method"))
       if (correlation_me_method == "")  correlation_me_method = method
       dglap_me_method = var_list%get_sval (var_str ("$dglap_me_method"))
       if (dglap_me_method == "")  dglap_me_method = method
       call msg_debug2 (D_PROCESS_INTEGRATION, &
            "process_init_blha_cores: method = ", method)
       call msg_debug2 (D_PROCESS_INTEGRATION, &
            "process_init_blha_cores: method = ", born_me_method)
       call msg_debug2 (D_PROCESS_INTEGRATION, &
            "process_init_blha_cores: method = ", loop_me_method)
       call msg_debug2 (D_PROCESS_INTEGRATION, &
            "process_init_blha_cores: method = ", correlation_me_method)
       call msg_debug2 (D_PROCESS_INTEGRATION, &
            "process_init_blha_cores: method = ", dglap_me_method)
       select case (nlo_type)
       case (BORN)
          if (needs_entry (method) .or. needs_entry (born_me_method)) &
             call blha_template%set_born ()
       case (NLO_REAL)
          if (needs_entry (real_tree_me_method)) &
             call blha_template%set_real_trees ()
       case (NLO_VIRTUAL)
          if (needs_entry (loop_me_method)) &
             call blha_template%set_loop ()
       case (NLO_SUBTRACTION)
          if (needs_entry (correlation_me_method)) then
             call blha_template%set_subtraction ()
             call blha_template%set_internal_color_correlations ()
          end if
       case (NLO_DGLAP)
          if (needs_entry (dglap_me_method)) then
             call blha_template%set_dglap ()
          end if
       end select
     end subroutine fill_blha_template
   end subroutine process_init_blha_cores
 
 @ %def process_init_blha_cores
 @
 <<Process: process: TBP>>=
   procedure :: get_n_cores => process_get_n_cores
 <<Process: procedures>>=
   function process_get_n_cores (process) result (n)
     integer :: n
     class(process_t), intent(in) :: process
     n = process%cm%n_cores
   end function process_get_n_cores
 
 @ %def process_get_n_cores
 @
 <<Process: process: TBP>>=
   procedure :: get_core_manager_index => process_get_core_manager_index
 <<Process: procedures>>=
   function process_get_core_manager_index (process, i_core) result (i)
     integer :: i
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_core
     i = process%cm%i_core_to_first_i_component (i_core)
   end function process_get_core_manager_index
 
 @ %def process_get_core_manager_index
 @
 <<Process: process: TBP>>=
   procedure :: get_core_manager => process_get_core_manager
 <<Process: procedures>>=
   function process_get_core_manager (process) result (cm)
     type(core_manager_t) :: cm
     class(process_t), intent(in) :: process
     cm = process%cm
   end function process_get_core_manager
 
 @ %def process_get_core_manager
 @
 <<Process: process: TBP>>=
   procedure :: get_core_manager_ptr => process_get_core_manager_ptr
 <<Process: procedures>>=
   function process_get_core_manager_ptr (process) result (cm)
     type(core_manager_t), pointer :: cm
     class(process_t), intent(in), target :: process
     cm => process%cm
   end function process_get_core_manager_ptr
 
 @ %def process_get_core_manager_ptr
 @
 <<Process: process: TBP>>=
   procedure :: get_base_i_term => process_get_base_i_term
 <<Process: procedures>>=
   function process_get_base_i_term (process, i_component) result (i_term)
     integer :: i_term
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_component
     i_term = process%component(i_component)%i_term(1)
   end function process_get_base_i_term
 
 @ %def process_get_base_i_term
 @
 <<Process: process: TBP>>=
   procedure :: get_core_term => process_get_core_term
 <<Process: procedures>>=
   function process_get_core_term (process, i_term) result (core)
     class(prc_core_t), pointer :: core
     class(process_t), intent(in), target :: process
     integer, intent(in) :: i_term
     integer :: i_core
     i_core = process%term(i_term)%i_core
     core => process%cm%cores(i_core)%core
   end function process_get_core_term
 
 @ %def process_get_core_term
 @
 <<Process: process: TBP>>=
   procedure :: get_subtraction_core => process_get_subtraction_core
 <<Process: procedures>>=
   function process_get_subtraction_core (process) result (core)
     class(prc_core_t), pointer :: core
     class(process_t), intent(in), target :: process
     core => process%cm%get_subtraction_core ()
   end function process_get_subtraction_core
 
 @ %def process_get_subtraction_core
 @
 <<Process: process: TBP>>=
   procedure :: get_term_ptr => process_get_term_ptr
 <<Process: procedures>>=
   function process_get_term_ptr (process, i) result (term)
     type(process_term_t), pointer :: term
     class(process_t), intent(in), target :: process
     integer, intent(in) :: i
     term => process%term(i)
   end function process_get_term_ptr
 
 @ %def process_get_term_ptr
 @
 <<Process: process: TBP>>=
   procedure :: get_core_from_md5sum => process_get_core_from_md5sum
 <<Process: procedures>>=
   function process_get_core_from_md5sum (process, md5sum) result (core)
     class(prc_core_t), pointer :: core
     class(process_t), intent(in), target :: process
     character(32), intent(in) :: md5sum
     integer :: i_core
     associate (cm => process%cm)
        do i_core = 1, N_MAX_CORES
           if (cm%md5s(i_core) == md5sum) exit
        end do
        core => cm%cores(i_core)%core
     end associate
   end function process_get_core_from_md5sum
 
 @ %def process_get_core_from_md5sum
 @
 <<Process: process: TBP>>=
   procedure :: get_i_core_nlo_type => process_get_i_core_nlo_type
 <<Process: procedures>>=
   function process_get_i_core_nlo_type (process, nlo_type, include_sub) result (i_core)
     integer :: i_core
     class(process_t), intent(in) :: process
     integer, intent(in) :: nlo_type
     logical, intent(in), optional :: include_sub
     logical :: skip_sub
     skip_sub = .false.
     if (present (include_sub)) skip_sub = .not. include_sub
     do i_core = 1, N_MAX_CORES
        if (skip_sub) then
           if (process%cm%sub(i_core)) cycle
        end if
        if (process%cm%nlo_type (i_core) == nlo_type) return
     end do
     i_core = -1
   end function process_get_i_core_nlo_type
 
 @ %def process_get_i_core_nlo_type
 @
 <<Process: process: TBP>>=
   procedure :: get_i_term => process_get_i_term
 <<Process: procedures>>=
   function process_get_i_term (process, i_core) result (i_term)
     integer :: i_term
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_core
     do i_term = 1, process%get_n_terms ()
        if (process%term(i_term)%i_core == i_core) return
     end do
     i_term = -1
   end function process_get_i_term
 
 @ %def process_get_i_term
 @
 <<Process: process: TBP>>=
   procedure :: set_i_mci_work => process_set_i_mci_work
 <<Process: procedures>>=
   subroutine process_set_i_mci_work (process, i_mci)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_mci
     process%mci_entry(i_mci)%i_mci = i_mci
   end subroutine process_set_i_mci_work
 
 @ %def process_set_i_mci_work
 @
 <<Process: process: TBP>>=
   procedure :: get_i_mci_work => process_get_i_mci_work
 <<Process: procedures>>=
   pure function process_get_i_mci_work (process, i_mci) result (i_mci_work)
     integer :: i_mci_work
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_mci
     i_mci_work = process%mci_entry(i_mci)%i_mci
   end function process_get_i_mci_work
 
 @ %def process_get_i_mci_work
 @
 <<Process: process: TBP>>=
   procedure :: get_i_sub => process_get_i_sub
 <<Process: procedures>>=
   elemental function process_get_i_sub (process, i_term) result (i_sub)
     integer :: i_sub
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_term
     i_sub = process%term(i_term)%i_sub
   end function process_get_i_sub
 
 @ %def process_get_i_sub
 @
 <<Process: process: TBP>>=
   procedure :: get_i_term_virtual => process_get_i_term_virtual
 <<Process: procedures>>=
   elemental function process_get_i_term_virtual (process) result (i_term)
     integer :: i_term
     class(process_t), intent(in) :: process
     integer :: i_component
     i_term = 0
     do i_component = 1, size (process%component)
        if (process%component(i_component)%get_nlo_type () == NLO_VIRTUAL) &
             i_term = process%component(i_component)%i_term(1)
     end do
   end function process_get_i_term_virtual
 
 @ %def process_get_i_term_virtual
 @
 <<Process: process: TBP>>=
   generic :: component_is_active => component_is_active_single
   procedure :: component_is_active_single => process_component_is_active_single
 <<Process: procedures>>=
   elemental function process_component_is_active_single (process, i_comp) result (val)
     logical :: val
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_comp
     val = process%component(i_comp)%is_active ()
   end function process_component_is_active_single
 
 @ %def process_component_is_active_single
 @
 <<Process: process: TBP>>=
   generic :: component_is_active => component_is_active_all
   procedure :: component_is_active_all => process_component_is_active_all
 <<Process: procedures>>=
   pure function process_component_is_active_all (process) result (val)
     logical, dimension(:), allocatable :: val
     class(process_t), intent(in) :: process
     allocate (val (size (process%component)))
     val = process%component%is_active ()
   end function process_component_is_active_all
 
 @ %def process_component_is_active_all
 @
 \subsection{Default iterations}
 If the user does not specify the passes and iterations for
 integration, we should be able to give reasonable defaults.  These
 depend on the process, therefore we implement the following procedures
 as methods of the process object.  The algorithm is not very
 sophisticated yet, it may be improved by looking at the process in
 more detail.
 
 We investigate only the first process component, assuming that it
 characterizes the complexity of the process reasonable well.
 
 The number of passes is limited to two: one for adaption, one for
 integration.
 <<Process: process: TBP>>=
   procedure :: get_n_pass_default => process_get_n_pass_default
   procedure :: adapt_grids_default => process_adapt_grids_default
   procedure :: adapt_weights_default => process_adapt_weights_default
 <<Process: procedures>>=
   function process_get_n_pass_default (process) result (n_pass)
     class(process_t), intent(in) :: process
     integer :: n_pass
     integer :: n_eff
     type(process_component_def_t), pointer :: config
     config => process%component(1)%config
     n_eff = config%get_n_tot () - 2
     select case (n_eff)
     case (1)
        n_pass = 1
     case default
        n_pass = 2
     end select
   end function process_get_n_pass_default
 
   function process_adapt_grids_default (process, pass) result (flag)
     class(process_t), intent(in) :: process
     integer, intent(in) :: pass
     logical :: flag
     integer :: n_eff
     type(process_component_def_t), pointer :: config
     config => process%component(1)%config
     n_eff = config%get_n_tot () - 2
     select case (n_eff)
     case (1)
        flag = .false.
     case default
        select case (pass)
        case (1);  flag = .true.
        case (2);  flag = .false.
        case default
           call msg_bug ("adapt grids default: impossible pass index")
        end select
     end select
   end function process_adapt_grids_default
 
   function process_adapt_weights_default (process, pass) result (flag)
     class(process_t), intent(in) :: process
     integer, intent(in) :: pass
     logical :: flag
     integer :: n_eff
     type(process_component_def_t), pointer :: config
     config => process%component(1)%config
     n_eff = config%get_n_tot () - 2
     select case (n_eff)
     case (1)
        flag = .false.
     case default
        select case (pass)
        case (1);  flag = .true.
        case (2);  flag = .false.
        case default
           call msg_bug ("adapt weights default: impossible pass index")
        end select
     end select
   end function process_adapt_weights_default
 
 @ %def process_get_n_pass_default
 @ %def process_adapt_grids_default
 @ %def process_adapt_weights_default
 @ The number of iterations and calls per iteration depends on the
 number of outgoing particles.
 <<Process: process: TBP>>=
   procedure :: get_n_it_default => process_get_n_it_default
   procedure :: get_n_calls_default => process_get_n_calls_default
 <<Process: procedures>>=
   function process_get_n_it_default (process, pass) result (n_it)
     class(process_t), intent(in) :: process
     integer, intent(in) :: pass
     integer :: n_it
     integer :: n_eff
     type(process_component_def_t), pointer :: config
     config => process%component(1)%config
     n_eff = config%get_n_tot () - 2
     select case (pass)
     case (1)
        select case (n_eff)
        case (1);   n_it = 1
        case (2);   n_it = 3
        case (3);   n_it = 5
        case (4:5); n_it = 10
        case (6);   n_it = 15
        case (7:);  n_it = 20
        end select
     case (2)
        select case (n_eff)
        case (:3);   n_it = 3
        case (4:);   n_it = 5
        end select
     end select
   end function process_get_n_it_default
 
   function process_get_n_calls_default (process, pass) result (n_calls)
     class(process_t), intent(in) :: process
     integer, intent(in) :: pass
     integer :: n_calls
     integer :: n_eff
     type(process_component_def_t), pointer :: config
     config => process%component(1)%config
     n_eff = config%get_n_tot () - 2
     select case (pass)
     case (1)
        select case (n_eff)
        case (1);   n_calls =   100
        case (2);   n_calls =  1000
        case (3);   n_calls =  5000
        case (4);   n_calls = 10000
        case (5);   n_calls = 20000
        case (6:);  n_calls = 50000
        end select
     case (2)
        select case (n_eff)
        case (:3);  n_calls =  10000
        case (4);   n_calls =  20000
        case (5);   n_calls =  50000
        case (6);   n_calls = 100000
        case (7:);  n_calls = 200000
        end select
     end select
   end function process_get_n_calls_default
 
 @ %def process_get_n_it_default
 @ %def process_get_n_calls_default
 @
 \subsection{Constant process data}
 The following methods return basic process data that stay constant
 after initialization.
 
 The process and IDs.
 <<Process: process: TBP>>=
   procedure :: get_id => process_get_id
   procedure :: get_num_id => process_get_num_id
   procedure :: get_run_id => process_get_run_id
   procedure :: get_library_name => process_get_library_name
 <<Process: procedures>>=
   function process_get_id (process) result (id)
     class(process_t), intent(in) :: process
     type(string_t) :: id
     id = process%meta%id
   end function process_get_id
 
   function process_get_num_id (process) result (id)
     class(process_t), intent(in) :: process
     integer :: id
     id = process%meta%num_id
   end function process_get_num_id
 
   function process_get_run_id (process) result (id)
     class(process_t), intent(in) :: process
     type(string_t) :: id
     id = process%meta%run_id
   end function process_get_run_id
 
   function process_get_library_name (process) result (id)
     class(process_t), intent(in) :: process
     type(string_t) :: id
     id = process%meta%lib%get_name ()
   end function process_get_library_name
 
 @ %def process_get_id process_get_num_id
 @ %def process_get_run_id process_get_library_name
 @ The number of incoming particles.
 <<Process: process: TBP>>=
   procedure :: get_n_in => process_get_n_in
 <<Process: procedures>>=
   function process_get_n_in (process) result (n)
     class(process_t), intent(in) :: process
     integer :: n
     n = process%config%n_in
   end function process_get_n_in
 
 @ %def process_get_n_in
 @ The number of MCI data sets.
 <<Process: process: TBP>>=
   procedure :: get_n_mci => process_get_n_mci
 <<Process: procedures>>=
   function process_get_n_mci (process) result (n)
     class(process_t), intent(in) :: process
     integer :: n
     n = process%config%n_mci
   end function process_get_n_mci
 
 @ %def process_get_n_mci
 @ The number of process components, total.
 <<Process: process: TBP>>=
   procedure :: get_n_components => process_get_n_components
 <<Process: procedures>>=
   function process_get_n_components (process) result (n)
     class(process_t), intent(in) :: process
     integer :: n
     n = process%meta%n_components
   end function process_get_n_components
 
 @ %def process_get_n_components
 @ The number of process terms, total.
 <<Process: process: TBP>>=
   procedure :: get_n_terms => process_get_n_terms
 <<Process: procedures>>=
   function process_get_n_terms (process) result (n)
     class(process_t), intent(in) :: process
     integer :: n
     n = process%config%n_terms
   end function process_get_n_terms
 
 @ %def process_get_n_terms
 @ Return the indices of the components that belong to a
 specific MCI entry.
 <<Process: process: TBP>>=
   procedure :: get_i_component => process_get_i_component
 <<Process: procedures>>=
   subroutine process_get_i_component (process, i_mci, i_component)
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_mci
     integer, dimension(:), intent(out), allocatable :: i_component
     associate (mci_entry => process%mci_entry(i_mci))
       allocate (i_component (size (mci_entry%i_component)))
       i_component = mci_entry%i_component
     end associate
   end subroutine process_get_i_component
 
 @ %def process_get_i_component
 @ Return the ID of a specific component.
 <<Process: process: TBP>>=
   procedure :: get_component_id => process_get_component_id
 <<Process: procedures>>=
   function process_get_component_id (process, i_component) result (id)
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_component
     type(string_t) :: id
     id = process%meta%component_id(i_component)
   end function process_get_component_id
 
 @ %def process_get_component_id
 @ Return a pointer to the definition of a specific component.
 <<Process: process: TBP>>=
   procedure :: get_component_def_ptr => process_get_component_def_ptr
 <<Process: procedures>>=
   function process_get_component_def_ptr (process, i_component) result (ptr)
     type(process_component_def_t), pointer :: ptr
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_component
     ptr => process%meta%lib%get_component_def_ptr (process%meta%id, i_component)
   end function process_get_component_def_ptr
 
 @ %def process_get_component_def_ptr
 @ These procedures extract and restore (by transferring the
 allocation) the process core.  This is useful for changing process
 parameters from outside this module.
 <<Process: process: TBP>>=
   procedure :: extract_core => process_extract_core
   procedure :: restore_core => process_restore_core
 <<Process: procedures>>=
   subroutine process_extract_core (process, i_term, core)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_term
     class(prc_core_t), intent(inout), allocatable :: core
     integer :: i_core
     i_core = process%term(i_term)%i_core
     call move_alloc (from = process%cm%cores(i_core)%core, to = core)
   end subroutine process_extract_core
 
   subroutine process_restore_core (process, i_term, core)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_term
     class(prc_core_t), intent(inout), allocatable :: core
     integer :: i_core
     i_core = process%term(i_term)%i_core
     call move_alloc (from = core, to = process%cm%cores(i_core)%core)
   end subroutine process_restore_core
 
 @ %def process_extract_core
 @ %def process_restore_core
 @ The block of process constants.
 <<Process: process: TBP>>=
   procedure :: get_constants => process_get_constants
 <<Process: procedures>>=
   function process_get_constants (process, i_core) result (data)
     type(process_constants_t) :: data
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_core
     data = process%cm%cores(i_core)%core%data
   end function process_get_constants
 
 @ %def process_get_constants
 @
 <<Process: process: TBP>>=
   procedure :: get_config => process_get_config
 <<Process: procedures>>=
   function process_get_config (process) result (config)
     type(process_config_data_t) :: config
     class(process_t), intent(in) :: process
     config = process%config
   end function process_get_config
 
 @ %def process_get_config
 @
 <<Process: process: TBP>>=
   procedure :: get_md5sum_constants => process_get_md5sum_constants
 <<Process: procedures>>=
   function process_get_md5sum_constants (process, i_component, &
      type_string, nlo_type) result (this_md5sum)
     character(32) :: this_md5sum
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_component
     type(string_t), intent(in) :: type_string
     integer, intent(in) :: nlo_type
     type(process_constants_t) :: data
     integer :: unit
     call process%meta%lib%fill_constants (process%meta%id, i_component, data)
     unit = data%fill_unit_for_md5sum (.false.)
     write (unit, '(A)') char(type_string)
     write (unit, '(I0)') nlo_type
     rewind (unit)
     this_md5sum = md5sum (unit)
     close (unit)
   end function process_get_md5sum_constants
 
 @ %def process_get_md5sum_constants
 @ Return the set of outgoing flavors that are associated with a particular
 term. We deduce this from the effective interaction.
 <<Process: process: TBP>>=
   procedure :: get_term_flv_out => process_get_term_flv_out
 <<Process: procedures>>=
   subroutine process_get_term_flv_out (process, i_term, flv)
     class(process_t), intent(in), target :: process
     integer, intent(in) :: i_term
     type(flavor_t), dimension(:,:), allocatable, intent(out) :: flv
     type(interaction_t), pointer :: int
     int => process%term(i_term)%int_eff
     if (.not. associated (int))  int => process%term(i_term)%int
     call interaction_get_flv_out (int, flv)
   end subroutine process_get_term_flv_out
 
 @ %def process_get_term_flv_out
 @ Return true if there is any unstable particle in any of the process
 terms.  We decide this based on the provided model instance, not the
 one that is stored in the process object.
 <<Process: process: TBP>>=
   procedure :: contains_unstable => process_contains_unstable
 <<Process: procedures>>=
   function process_contains_unstable (process, model) result (flag)
     class(process_t), intent(in) :: process
     class(model_data_t), intent(in), target :: model
     logical :: flag
     integer :: i_term
     type(flavor_t), dimension(:,:), allocatable :: flv
     flag = .false.
     do i_term = 1, process%get_n_terms ()
        call process%get_term_flv_out (i_term, flv)
        call flv%set_model (model)
        flag = .not. all (flv%is_stable ())
        deallocate (flv)
        if (flag)  return
     end do
   end function process_contains_unstable
 
 @ %def process_contains_unstable
 @ The nominal process energy.
 <<Process: process: TBP>>=
   procedure :: get_sqrts => process_get_sqrts
 <<Process: procedures>>=
   function process_get_sqrts (process) result (sqrts)
     class(process_t), intent(in) :: process
     real(default) :: sqrts
     sqrts = process%beam_config%data%get_sqrts ()
   end function process_get_sqrts
 
 @ %def process_get_sqrts
 @ The beam polarization in case of simple degrees.
 <<Process: process: TBP>>=
   procedure :: get_polarization => process_get_polarization
 <<Process: procedures>>=
   function process_get_polarization (process) result (pol)
     class(process_t), intent(in) :: process
     real(default), dimension(2) :: pol
     pol = process%beam_config%data%get_polarization ()
   end function process_get_polarization
 
 @ %def process_get_polarization
 @
 <<Process: process: TBP>>=
   procedure :: get_meta => process_get_meta
 <<Process: procedures>>=
   function process_get_meta (process) result (meta)
     type(process_metadata_t) :: meta
     class(process_t), intent(in) :: process
     meta = process%meta
   end function process_get_meta
 
 @ %def process_get_meta
 <<Process: process: TBP>>=
   procedure :: has_matrix_element => process_has_matrix_element
 <<Process: procedures>>=
   function process_has_matrix_element (process, i, is_term_index) result (active)
     logical :: active
     class(process_t), intent(in) :: process
     integer, intent(in), optional :: i
     logical, intent(in), optional :: is_term_index
     integer :: i_component
     logical :: is_term
     is_term = .false.
     if (present (i)) then
        if (present (is_term_index)) is_term = is_term_index
        if (is_term) then
           i_component = process%term(i)%i_component
        else
           i_component = i
        end if
        active = process%component(i_component)%active
     else
        active = any (process%component%active)
     end if
   end function process_has_matrix_element
 
 @ %def process_has_matrix_element
 @ Pointer to the beam data object.
 <<Process: process: TBP>>=
   procedure :: get_beam_data_ptr => process_get_beam_data_ptr
 <<Process: procedures>>=
   function process_get_beam_data_ptr (process) result (beam_data)
     class(process_t), intent(in), target :: process
     type(beam_data_t), pointer :: beam_data
     beam_data => process%beam_config%data
   end function process_get_beam_data_ptr
 
 @ %def process_get_beam_data_ptr
 @
 <<Process: process: TBP>>=
   procedure :: get_beam_config => process_get_beam_config
 <<Process: procedures>>=
   function process_get_beam_config (process) result (beam_config)
     type(process_beam_config_t) :: beam_config
     class(process_t), intent(in) :: process
     beam_config = process%beam_config
   end function process_get_beam_config
 
 @ %def process_get_beam_config
 @
 <<Process: process: TBP>>=
   procedure :: get_beam_config_ptr => process_get_beam_config_ptr
 <<Process: procedures>>=
   function process_get_beam_config_ptr (process) result (beam_config)
     type(process_beam_config_t), pointer :: beam_config
     class(process_t), intent(in), target :: process
     beam_config => process%beam_config
   end function process_get_beam_config_ptr
 
 @ %def process_get_beam_config_ptr
 @ Return true if lab and c.m.\ frame coincide for this process.
 <<Process: process: TBP>>=
   procedure :: cm_frame => process_cm_frame
 <<Process: procedures>>=
   function process_cm_frame (process) result (flag)
     class(process_t), intent(in), target :: process
     logical :: flag
     type(beam_data_t), pointer :: beam_data
     beam_data => process%beam_config%data
     flag = beam_data%cm_frame ()
   end function process_cm_frame
 
 @ %def process_cm_frame
 @ Get the PDF set currently in use, if any.
 <<Process: process: TBP>>=
   procedure :: get_pdf_set => process_get_pdf_set
 <<Process: procedures>>=
   function process_get_pdf_set (process) result (pdf_set)
     class(process_t), intent(in) :: process
     integer :: pdf_set
     pdf_set = process%beam_config%get_pdf_set ()
   end function process_get_pdf_set
 
 @ %def process_get_pdf_set
 @
 <<Process: process: TBP>>=
   procedure :: pcm_contains_pdfs => process_pcm_contains_pdfs
 <<Process: procedures>>=
   function process_pcm_contains_pdfs (process) result (has_pdfs)
     logical :: has_pdfs
     class(process_t), intent(in) :: process
     has_pdfs = process%pcm%has_pdfs
   end function process_pcm_contains_pdfs
 
 @ %def process_pcm_contains_pdfs
 @ Get the beam spectrum file currently in use, if any.
 <<Process: process: TBP>>=
   procedure :: get_beam_file => process_get_beam_file
 <<Process: procedures>>=
   function process_get_beam_file (process) result (file)
     class(process_t), intent(in) :: process
     type(string_t) :: file
     file = process%beam_config%get_beam_file ()
   end function process_get_beam_file
 
 @ %def process_get_beam_file
 @ Pointer to the process variable list.
 <<Process: process: TBP>>=
   procedure :: get_var_list_ptr => process_get_var_list_ptr
 <<Process: procedures>>=
   function process_get_var_list_ptr (process) result (ptr)
     class(process_t), intent(in), target :: process
     type(var_list_t), pointer :: ptr
     ptr => process%meta%var_list
   end function process_get_var_list_ptr
 
 @ %def process_get_var_list_ptr
 @ Pointer to the common model.
 <<Process: process: TBP>>=
   procedure :: get_model_ptr => process_get_model_ptr
 <<Process: procedures>>=
   function process_get_model_ptr (process) result (ptr)
     class(process_t), intent(in) :: process
     class(model_data_t), pointer :: ptr
     ptr => process%config%model
   end function process_get_model_ptr
 
 @ %def process_get_model_ptr
 @ Use the embedded RNG factory to spawn a new random-number generator
 instance.  (This modifies the state of the factory.)
 <<Process: process: TBP>>=
   procedure :: make_rng => process_make_rng
 <<Process: procedures>>=
   subroutine process_make_rng (process, rng)
     class(process_t), intent(inout) :: process
     class(rng_t), intent(out), allocatable :: rng
     if (allocated (process%config%rng_factory)) then
        call process%config%rng_factory%make (rng)
     else
        call msg_bug ("Process: make rng: factory not allocated")
     end if
   end subroutine process_make_rng
 
 @ %def process_make_rng
 @
 \subsection{Compute an amplitude}
 Each process variant should allow for computing an amplitude value
 directly, without generating a process instance.
 
 The process component is selected by the index [[i]].  The term within the
 process component is selected by [[j]].  The momentum
 combination is transferred as the array [[p]].  The function sets the specific
 quantum state via the indices of a flavor [[f]], helicity [[h]], and color
 [[c]] combination.  Each index refers to the list of flavor, helicity, and
 color states, respectively, as stored in the process data.
 
 Optionally, we may set factorization and renormalization scale.  If unset, the
 partonic c.m.\ energy is inserted.
 
 The function checks arguments for validity.
 For invalid arguments (quantum states), we return zero.
 <<Process: process: TBP>>=
   procedure :: compute_amplitude => process_compute_amplitude
 <<Process: procedures>>=
   function process_compute_amplitude &
        (process, i_core, i, j, p, f, h, c, fac_scale, ren_scale, alpha_qcd_forced) &
        result (amp)
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_core
     integer, intent(in) :: i, j
     type(vector4_t), dimension(:), intent(in) :: p
     integer, intent(in) :: f, h, c
     real(default), intent(in), optional :: fac_scale, ren_scale
     real(default), intent(in), allocatable, optional :: alpha_qcd_forced
     class(prc_core_t), pointer :: core => null ()
     real(default) :: fscale, rscale
     real(default), allocatable :: aqcd_forced
     complex(default) :: amp
     amp = 0
     if (0 < i .and. i <= process%meta%n_components) then
        core => process%cm%get_core(i_core)
        if (process%component(i)%active) then
           !associate (data => process%component(i)%core%data)
           associate (data => core%data)
             if (size (p) == data%n_in + data%n_out &
                  .and. 0 < f .and. f <= data%n_flv &
                  .and. 0 < h .and. h <= data%n_hel &
                  .and. 0 < c .and. c <= data%n_col) then
                if (present (fac_scale)) then
                   fscale = fac_scale
                else
                   fscale = sum (p(data%n_in+1:)) ** 1
                end if
                if (present (ren_scale)) then
                   rscale = ren_scale
                else
                   rscale = fscale
                end if
                if (present (alpha_qcd_forced)) then
                   if (allocated (alpha_qcd_forced)) &
                        allocate (aqcd_forced, source = alpha_qcd_forced)
                end if
                amp = core%compute_amplitude (j, p, f, h, c, &
                   fscale, rscale, aqcd_forced)
             end if
           end associate
        else
           amp = 0
        end if
     end if
   end function process_compute_amplitude
 
 @ %def process_compute_amplitude
 @ Sanity check for the process library.  We abort the program if it
 has changed after process initialization.
 <<Process: process: TBP>>=
   procedure :: check_library_sanity => process_check_library_sanity
 <<Process: procedures>>=
   subroutine process_check_library_sanity (process)
     class(process_t), intent(in) :: process
     if (associated (process%meta%lib)) then
        if (process%meta%lib%get_update_counter () /= process%meta%lib_update_counter) then
           call msg_fatal ("Process '" // char (process%get_id ()) &
                // "': library has been recompiled after integration")
        end if
     end if
   end subroutine process_check_library_sanity
 
 @ %def process_check_library_sanity
 @ Execute this for testing purposes, to avoid a dangling pointer in the above
 sanity check.  Effectively switches off the sanity check.
 <<Process: process: TBP>>=
   procedure :: nullify_library_pointer => process_nullify_library_pointer
 <<Process: procedures>>=
   subroutine process_nullify_library_pointer (process)
     class(process_t), intent(inout) :: process
     process%meta%lib => null ()
   end subroutine process_nullify_library_pointer
 
 @ %def process_nullify_library_pointer
 @
 <<Process: process: TBP>>=
   procedure :: set_component_type => process_set_component_type
 <<Process: procedures>>=
   subroutine process_set_component_type (process, i_component, i_type)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_component, i_type
     process%component(i_component)%component_type = i_type
   end subroutine process_set_component_type
 
 @ %def process_set_component_type
 @
 <<Process: process: TBP>>=
   procedure :: set_counter_mci_entry => process_set_counter_mci_entry
 <<Process: procedures>>=
   subroutine process_set_counter_mci_entry (process, i_mci, counter)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_mci
     type(process_counter_t), intent(in) :: counter
     process%mci_entry(i_mci)%counter = counter
   end subroutine process_set_counter_mci_entry
 
 @ %def process_set_counter_mci_entry
 @ This is for suppression of numerical noise in the integration results
 stored in the [[process_mci_entry]] type. As the error and efficiency
 enter the MD5 sum, we recompute it.
 <<Process: process: TBP>>=
   procedure :: pacify => process_pacify
 <<Process: procedures>>=
   subroutine process_pacify (process, efficiency_reset, error_reset)
     class(process_t), intent(inout) :: process
     logical, intent(in), optional :: efficiency_reset, error_reset
     logical :: eff_reset, err_reset
     integer :: i
     eff_reset = .false.
     err_reset = .false.
     if (present (efficiency_reset))  eff_reset = efficiency_reset
     if (present (error_reset))  err_reset = error_reset
     if (allocated (process%mci_entry)) then
        do i = 1, size (process%mci_entry)
           call process%mci_entry(i)%results%pacify (efficiency_reset)
           if (allocated (process%mci_entry(i)%mci)) then
              associate (mci => process%mci_entry(i)%mci)
                if (process%mci_entry(i)%mci%error_known &
                     .and. err_reset) &
                     mci%error = 0
                if (process%mci_entry(i)%mci%efficiency_known &
                     .and. eff_reset)  &
                     mci%efficiency = 1
                call mci%pacify (efficiency_reset, error_reset)
                call mci%compute_md5sum ()
              end associate
           end if
        end do
     end if
   end subroutine process_pacify
 
 @ %def process_pacify
 @ The following methods are used only in the unit tests; the access
 process internals directly that would otherwise be hidden.
 <<Process: process: TBP>>=
   procedure :: test_allocate_sf_channels
   procedure :: test_set_component_sf_channel
   procedure :: test_get_mci_ptr
 <<Process: procedures>>=
   subroutine test_allocate_sf_channels (process, n)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: n
     call process%beam_config%allocate_sf_channels (n)
   end subroutine test_allocate_sf_channels
 
   subroutine test_set_component_sf_channel (process, c)
     class(process_t), intent(inout) :: process
     integer, dimension(:), intent(in) :: c
     call process%component(1)%phs_config%set_sf_channel (c)
   end subroutine test_set_component_sf_channel
 
   subroutine test_get_mci_ptr (process, mci)
     class(process_t), intent(in), target :: process
     class(mci_t), intent(out), pointer :: mci
     mci => process%mci_entry(1)%mci
   end subroutine test_get_mci_ptr
 
 @ %def test_allocate_sf_channels
 @ %def test_set_component_sf_channel
 @ %def test_get_mci_ptr
 @
 <<Process: process: TBP>>=
   procedure :: init_mci_work => process_init_mci_work
 <<Process: procedures>>=
   subroutine process_init_mci_work (process, mci_work, i)
     class(process_t), intent(in), target :: process
     type(mci_work_t), intent(out) :: mci_work
     integer, intent(in) :: i
     call mci_work%init (process%mci_entry(i))
   end subroutine process_init_mci_work
 
 @ %def process_init_mci_work
 @
 <<Process: process: TBP>>=
   procedure :: setup_test_cores => process_setup_test_cores
 <<Process: procedures>>=
   subroutine process_setup_test_cores (process, type_string)
     class(process_t), intent(inout) :: process
     class(prc_core_t), allocatable :: core
     type(string_t), intent(in), optional :: type_string
     allocate (test_t :: core)
     if (present (type_string)) then
        call process%core_manager_register (BORN, 1, type_string)
     else
        call process%core_manager_register (BORN, 1, var_str ("test_me"))
     end if
     call process%allocate_cm_arrays (1)
     call process%allocate_core (1, core)
     call process%init_cores ()
   end subroutine process_setup_test_cores
 
 @ %def process_setup_test_cores
 @
 <<Process: process: TBP>>=
   procedure :: write_cm => process_write_cm
 <<Process: procedures>>=
   subroutine process_write_cm (process, unit)
     class(process_t), intent(in) :: process
     integer, intent(in), optional :: unit
     call process%cm%write (unit)
   end subroutine process_write_cm
 
 @ %def process_write_cm
 <<Process: process: TBP>>=
   procedure :: get_connected_states => process_get_connected_states
 <<Process: procedures>>=
   function process_get_connected_states (process, i_component, &
          connected_terms) result (connected)
     type(connected_state_t), dimension(:), allocatable :: connected
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_component
     type(connected_state_t), dimension(:), intent(in) :: connected_terms
     integer :: i, i_conn
     integer :: n_conn
     n_conn = 0
     do i = 1, process%get_n_terms ()
        if (process%term(i)%i_component == i_component) then
           n_conn = n_conn + 1
        end if
     end do
     allocate (connected (n_conn))
     i_conn = 1
     do i = 1, process%get_n_terms ()
        if (process%term(i)%i_component == i_component) then
           connected (i_conn) = connected_terms(i)
           i_conn = i_conn + 1
        end if
     end do
   end function process_get_connected_states
 
 @ %def process_get_connected_states
 @
 \subsection{NLO specifics}
 These subroutines (and the NLO specific properties they work on) could
 potentially be moved to [[pcm_nlo_t]] and used more generically in
 [[process_t]] with an appropriate interface in [[pcm_t]]
 <<Process: process: TBP>>=
   procedure :: init_nlo_settings => process_init_nlo_settings
 <<Process: procedures>>=
   subroutine process_init_nlo_settings (process, var_list, fks_template)
     class(process_t), intent(inout) :: process
     type(var_list_t), intent(in), target :: var_list
     type(fks_template_t), intent(in), optional :: fks_template
     select type (pcm => process%pcm)
     type is (pcm_nlo_t)
        call pcm%settings%init (var_list, fks_template)
        if (debug_active (D_SUBTRACTION) .or. debug_active (D_VIRTUAL)) &
               call pcm%settings%write ()
     class default
        call msg_fatal ("Attempt to set nlo_settings with a non-NLO pcm!")
     end select
   end subroutine process_init_nlo_settings
 
 @ %def process_init_nlo_settings
 @
 <<Process: process: TBP>>=
   procedure :: get_nlo_type => process_get_nlo_type
 <<Process: procedures>>=
   elemental function process_get_nlo_type (process, i_core) result (nlo_type)
     integer :: nlo_type
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_core
     nlo_type = process%cm%nlo_type(i_core)
   end function process_get_nlo_type
 
 @ %def process_get_nlo_type
 @
 <<Process: process: TBP>>=
   generic :: get_nlo_type_component => get_nlo_type_component_single
   procedure :: get_nlo_type_component_single => process_get_nlo_type_component_single
 <<Process: procedures>>=
   elemental function process_get_nlo_type_component_single (process, i_component) result (val)
     integer :: val
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_component
     val = process%component(i_component)%get_nlo_type ()
   end function process_get_nlo_type_component_single
 
 @ %def process_get_nlo_type_component_single
 @
 <<Process: process: TBP>>=
   generic :: get_nlo_type_component => get_nlo_type_component_all
   procedure :: get_nlo_type_component_all => process_get_nlo_type_component_all
 <<Process: procedures>>=
   pure function process_get_nlo_type_component_all (process) result (val)
     integer, dimension(:), allocatable :: val
     class(process_t), intent(in) :: process
     allocate (val (size (process%component)))
     val = process%component%get_nlo_type ()
   end function process_get_nlo_type_component_all
 
 @ %def process_get_nlo_type_component_all
 @
 <<Process: process: TBP>>=
   procedure :: is_nlo_calculation => process_is_nlo_calculation
 <<Process: procedures>>=
   function process_is_nlo_calculation (process) result (nlo)
     logical :: nlo
     class(process_t), intent(in) :: process
     select type (pcm => process%pcm)
     type is (pcm_nlo_t)
        nlo = .true.
     class default
        nlo = .false.
     end select
   end function process_is_nlo_calculation
 
 @ %def process_is_nlo_calculation
 @
 <<Process: process: TBP>>=
   procedure :: is_combined_nlo_integration &
        => process_is_combined_nlo_integration
 <<Process: procedures>>=
   function process_is_combined_nlo_integration (process) result (combined)
     logical :: combined
     class(process_t), intent(in) :: process
     select type (pcm => process%pcm)
     type is (pcm_nlo_t)
        combined = pcm%settings%combined_integration
     class default
        combined = .false.
     end select
   end function process_is_combined_nlo_integration
 
 @ %def process_is_combined_nlo_integration
 @
 <<Process: process: TBP>>=
   procedure :: component_is_real_finite => process_component_is_real_finite
 <<Process: procedures>>=
   pure function process_component_is_real_finite (process, i_component) &
          result (val)
     logical :: val
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_component
     val = process%component(i_component)%component_type == COMP_REAL_FIN
   end function process_component_is_real_finite
 
 @ %def process_component_is_real_finite
 @ Return nlo data of a process component
 <<Process: process: TBP>>=
   procedure :: get_component_nlo_type => process_get_component_nlo_type
 <<Process: procedures>>=
   elemental function process_get_component_nlo_type (process, i_component) &
            result (nlo_type)
     integer :: nlo_type
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_component
     nlo_type = process%component(i_component)%config%get_nlo_type ()
   end function process_get_component_nlo_type
 
 @ %def process_get_component_nlo_type
 <<Process: process: TBP>>=
   procedure :: get_component_associated_born &
             => process_get_component_associated_born
 <<Process: procedures>>=
   function process_get_component_associated_born (process, i_component) &
            result (i_born)
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_component
     integer :: i_born
     i_born = process%component(i_component)%config%get_associated_born ()
   end function process_get_component_associated_born
 
 @ %def process_get_component_associated_born
 @
 <<Process: process: TBP>>=
   procedure :: get_first_real_component => process_get_first_real_component
 <<Process: procedures>>=
   function process_get_first_real_component (process) result (i_real)
      integer :: i_real
      class(process_t), intent(in) :: process
      i_real = process%component(1)%config%get_associated_real ()
   end function process_get_first_real_component
 
 @ %def process_get_first_real_component
 @
 <<Process: process: TBP>>=
   procedure :: get_first_real_term => process_get_first_real_term
 <<Process: procedures>>=
   function process_get_first_real_term (process) result (i_real)
      integer :: i_real
      class(process_t), intent(in) :: process
      integer :: i_component, i_term
      i_component = process%component(1)%config%get_associated_real ()
      i_real = 0
      do i_term = 1, size (process%term)
         if (process%term(i_term)%i_component == i_component) then
            i_real = i_term
            exit
         end if
      end do
      if (i_real == 0) call msg_fatal ("Did not find associated real term!")
   end function process_get_first_real_term
 
 @ %def process_get_first_real_term
 @
 <<Process: process: TBP>>=
   procedure :: get_associated_real_fin => process_get_associated_real_fin
 <<Process: procedures>>=
   elemental function process_get_associated_real_fin (process, i_component) result (i_real)
      integer :: i_real
      class(process_t), intent(in) :: process
      integer, intent(in) :: i_component
      i_real = process%component(i_component)%config%get_associated_real_fin ()
   end function process_get_associated_real_fin
 
 @ %def process_get_associated_real_fin
 @
 <<Process: process: TBP>>=
   procedure :: setup_region_data => process_setup_region_data
 <<Process: procedures>>=
   subroutine process_setup_region_data (process, i_real, data_born, data_real)
     class(process_t), intent(inout) :: process
     integer, intent(in) :: i_real
     type(process_constants_t), intent(in) :: data_born, data_real
     integer, dimension (:,:), allocatable :: flavor_born, flavor_real
     type(resonance_history_t), dimension(:), allocatable :: resonance_histories
     logical :: success
     select type (pcm => process%pcm)
     type is (pcm_nlo_t)
        call data_born%get_flv_state (flavor_born)
        call data_real%get_flv_state (flavor_real)
        select type (model => process%config%model)
        type is (model_t)
           call pcm%region_data%init (data_born%n_in, model, &
                flavor_born, flavor_real, pcm%settings%nlo_correction_type)
           associate (template => pcm%settings%fks_template)
              if (template%mapping_type == FKS_RESONANCES) then
                 select type (phs_config => process%component(i_real)%phs_config)
                 type is (phs_fks_config_t)
                    call get_filtered_resonance_histories (phs_config, &
                         data_born%n_in, flavor_born, model, template%excluded_resonances, &
                         resonance_histories, success)
                 end select
                 if (.not. success) template%mapping_type = FKS_DEFAULT
              end if
              call pcm%region_data%setup_fks_mappings &
                   (pcm%settings%fks_template, data_born%n_in)
              !!! Check again, mapping_type might have changed
              if (template%mapping_type == FKS_RESONANCES) then
                 call pcm%region_data%set_resonance_mappings (resonance_histories)
                 call pcm%region_data%init_resonance_information ()
                 pcm%settings%use_resonance_mappings = .true.
              end if
           end associate
        end select
        if (pcm%settings%factorization_mode == FACTORIZATION_THRESHOLD) then
            call pcm%region_data%set_isr_pseudo_regions ()
            call pcm%region_data%split_up_interference_regions_for_threshold ()
        end if
        call pcm%region_data%compute_number_of_phase_spaces ()
        call pcm%region_data%set_i_phs_to_i_con ()
        associate (var_list => process%meta%var_list)
           call pcm%region_data%write_to_file (process%meta%id, &
                var_list%get_lval (var_str ("?vis_fks_regions")), &
                process%config%os_data)
        end associate
        if (debug_active (D_SUBTRACTION)) call pcm%region_data%check_consistency (.true.)
     end select
   end subroutine process_setup_region_data
 
 @ %def process_setup_region_data
 @
 <<Process: process: TBP>>=
   procedure :: setup_real_partition => process_setup_real_partition
 <<Process: procedures>>=
   subroutine process_setup_real_partition (process, partition_scale)
     class(process_t), intent(inout) :: process
     real(default), intent(in) :: partition_scale
     select type (pcm => process%pcm)
     type is (pcm_nlo_t)
        call pcm%setup_real_partition (partition_scale)
     end select
   end subroutine process_setup_real_partition
 
 @ %def process_setup_real_partition
 @
 <<Process: process: TBP>>=
   procedure :: check_if_threshold_method => process_check_if_threshold_method
 <<Process: procedures>>=
   subroutine process_check_if_threshold_method (process)
     class(process_t), intent(inout) :: process
     integer :: i_core
     associate (cm => process%cm)
        do i_core = 1, cm%n_cores
           select type (core => cm%cores(i_core)%core)
           type is (prc_threshold_t)
              select type (pcm => process%pcm)
              type is (pcm_nlo_t)
                 pcm%settings%factorization_mode = FACTORIZATION_THRESHOLD
              end select
           end select
        end do
     end associate
   end subroutine process_check_if_threshold_method
 
 @ %def process_check_if_threshold_method
 <<Process: process: TBP>>=
   procedure :: select_i_term => process_select_i_term
 <<Process: procedures>>=
   pure function process_select_i_term (process, i_mci) result (i_term)
     integer :: i_term
     class(process_t), intent(in) :: process
     integer, intent(in) :: i_mci
     integer :: i_component, i_sub
     i_component = process%mci_entry(i_mci)%i_component(1)
     i_term = process%component(i_component)%i_term(1)
     i_sub = process%term(i_term)%i_sub
     if (i_sub > 0) &
        i_term = process%term(i_sub)%i_term_global
   end function process_select_i_term
 
 @ %def process_select_i_term
 @
 <<Process: process: TBP>>=
   procedure :: create_blha_interface => process_create_blha_interface
 <<Process: procedures>>=
   subroutine process_create_blha_interface (process, flv_born, flv_real, n_in, beam_structure)
     class(process_t), intent(inout) :: process
     integer, intent(in), dimension(:,:), allocatable :: flv_born, flv_real
     integer, intent(in) :: n_in
     type(beam_structure_t), intent(in) :: beam_structure
     integer :: alpha_power, alphas_power
     type(blha_master_t) :: blha_master
     integer :: openloops_phs_tolerance, openloops_stability_log
     logical :: use_cms, use_collier
     type(string_t) :: openloops_extra_cmd
     type(string_t) :: ew_scheme, correction_type
     type(process_component_def_t), pointer :: config => null ()
     config => process%meta%lib%get_component_def_ptr (process%meta%id, 1)
     call config%get_coupling_powers (alpha_power, alphas_power)
     associate (cm => process%cm)
        associate (var_list => process%meta%var_list)
           openloops_phs_tolerance = &
                var_list%get_ival (var_str ("openloops_phs_tolerance"))
           openloops_stability_log = &
                var_list%get_ival (var_str ("openloops_stability_log"))
           openloops_extra_cmd = var_list%get_sval (var_str ("$openloops_extra_cmd"))
           use_cms = var_list%get_lval (var_str ("?openloops_use_cms"))
           use_collier = var_list%get_lval (var_str ("?openloops_use_collier"))
           ew_scheme = var_list%get_sval (var_str ("$blha_ew_scheme"))
           correction_type = var_list%get_sval (var_str ("$nlo_correction_type"))
           call blha_master%set_ew_scheme (ew_scheme)
        end associate
        call blha_master%set_methods &
             (process%is_nlo_calculation (), process%meta%var_list)
        call blha_master%allocate_config_files ()
        call blha_master%set_correction_type (correction_type)
        call blha_master%setup_additional_features (openloops_phs_tolerance, &
             use_cms, &
             openloops_stability_log, &
             use_collier, &
             extra_cmd = openloops_extra_cmd, &
             beam_structure = beam_structure)
        call blha_master%generate (process%meta%id, process%config%model, &
             n_in, alpha_power, alphas_power, flv_born, flv_real)
        call blha_master%write_olp (process%meta%id)
     end associate
   end subroutine process_create_blha_interface
 
 @ %def process_create_blha_interface
 @ Would be better to do this at the level of the writer of the core but
 one has to bring NLO information there.
 Could also be moved to the [[core_manager_t]].
 <<Process: process: TBP>>=
   procedure :: create_and_load_extra_libraries &
      => process_create_and_load_extra_libraries
 <<Process: procedures>>=
   subroutine process_create_and_load_extra_libraries &
        (process, beam_structure, var_list, os_data)
     class(process_t), intent(inout), target :: process
     type(beam_structure_t), intent(in) :: beam_structure
     type(var_list_t), intent(in) :: var_list
     type(os_data_t), intent(in) :: os_data
     type(string_t) :: libname
     integer :: i_component, i_core
     logical, dimension(process%cm%n_cores) :: loaded
     logical :: give_warning, is_nlo
     integer :: n_in
     integer, dimension(:,:), allocatable :: flv_born, flv_real
     type(process_component_def_t), pointer :: config => null ()
     integer :: nlo_type_fetched
 
     loaded = .false.
     call msg_debug2 (D_PROCESS_INTEGRATION, &
          "process_create_and_load_extra_libraries")
     select type (pcm => process%pcm)
     type is (pcm_nlo_t)
        call pcm%region_data%get_all_flv_states (flv_born, flv_real)
        n_in = pcm%region_data%get_n_in ()
        is_nlo = .true.
     class default
        i_core = process%get_i_core_nlo_type (BORN)
        is_nlo = .false.
        associate (core => process%cm%cores(i_core)%core)
           allocate (flv_born (core%data%get_n_tot (), core%data%n_flv))
           flv_born = core%data%flv_state
           n_in = core%data%n_in
        end associate
     end select
     if (process%needs_extra_code (only_blha = .true.)) &
          call process%create_blha_interface &
          (flv_born, flv_real, n_in, beam_structure)
     give_warning = .false.
     do i_component = 1, process%meta%n_components
        config => process%meta%lib%get_component_def_ptr &
             (process%meta%id, i_component)
        nlo_type_fetched = config%get_nlo_type ()
        if (nlo_type_fetched == NLO_MISMATCH)  nlo_type_fetched = NLO_SUBTRACTION
        i_core = process%get_i_core_nlo_type (nlo_type_fetched)
        if (config%can_be_integrated () .or. &
             process%get_nlo_type (i_core) == NLO_SUBTRACTION .or. &
             process%get_nlo_type (i_core) == NLO_REAL) then
           if (.not. loaded (i_core)) then
              select type (core => process%cm%cores(i_core)%core)
              class is (prc_user_defined_base_t)
                 libname = process%get_library_name ()
                 if (process%cm%core_is_radiation(i_core)) then
                    if (allocated (flv_real)) then
                       call core%data%set_flv_state (flv_real)
                    else
                       give_warning = .true.
                    end if
                    call msg_debug2 (D_PROCESS_INTEGRATION, &
                         "create and load radiation libraries")
                    call core%create_and_load_extra_libraries &
                         (flv_real, var_list, os_data, libname, &
                         process%config%model, i_core, is_nlo)
                 else
                    if (allocated (flv_born)) then
                       call core%data%set_flv_state (flv_born)
                    else
                       give_warning = .true.
                    end if
                    call msg_debug2 (D_PROCESS_INTEGRATION, &
                         "create and load Born libraries")
                    call core%create_and_load_extra_libraries &
                         (flv_born, var_list, os_data, libname, &
                         process%config%model, i_core, is_nlo)
                 end if
              end select
              select type (core => process%cm%cores(i_core)%core)
              type is (prc_threshold_t)
                 core%has_beam_pol = beam_structure%has_polarized_beams ()
              end select
              loaded(i_core) = .true.
           end if
        end if
     end do
     if (give_warning) call msg_warning ("Some flavor structures ", &
          [var_str ("are not allocated. This is totally fine if "), &
           var_str ("$method = 'threshold' is used, but you should "), &
           var_str ("have a closer look if this is not the case.")])
   end subroutine process_create_and_load_extra_libraries
 
 @ %def process_create_and_load_extra_libraries
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Process config}
 <<[[process_config.f90]]>>=
 <<File header>>
 
 module process_config
 
 <<Use kinds>>
 <<Use strings>>
   use format_utils, only: write_separator
   use io_units
   use md5
   use os_interface
   use diagnostics
   use sf_base
   use sf_mappings
   use sm_qcd
   use physics_defs
   use integration_results
   use model_data
   use interactions
   use quantum_numbers
   use flavors
   use helicities
   use colors
   use rng_base
   use state_matrices
   use process_libraries
   use process_constants
   use prc_core
   use prc_user_defined
   use prc_openloops, only: prc_openloops_t
   use prc_threshold, only: prc_threshold_t
   use beams
   use mci_base
   use beam_structures
   use phs_base
   use variables
   use expr_base
 
   use pcm_base, only: pcm_t
   use pcm, only: pcm_nlo_t
 
 <<Standard module head>>
 
 <<Process config: public>>
 
 <<Process config: parameters>>
 
 <<Process config: types>>
 
 contains
 
 <<Process config: procedures>>
 
 end module process_config
 @ %def process_config
 @
 <<Process config: parameters>>=
   integer, parameter, public :: COMP_DEFAULT = 0
   integer, parameter, public :: COMP_REAL_FIN = 1
   integer, parameter, public :: COMP_MASTER = 2
   integer, parameter, public :: COMP_VIRT = 3
   integer, parameter, public :: COMP_REAL = 4
   integer, parameter, public :: COMP_REAL_SING = 5
   integer, parameter, public :: COMP_MISMATCH = 6
   integer, parameter, public :: COMP_PDF = 7
   integer, parameter, public :: COMP_SUB = 8
   integer, parameter, public :: COMP_RESUM = 9
 
 @
 \subsection{Generic configuration data}
 This information concerns physical and technical properties of the
 process.  It is fixed upon initialization, using data from the
 process specification and the variable list.
 
 The number [[n_in]] is the number of incoming beam particles,
 simultaneously the number of incoming partons, 1 for a decay and 2 for
 a scattering process. (The number of outgoing partons may depend on
 the process component.)
 
 The number [[n_components]] is the number of components that constitute
 the current process.
 
 The number [[n_terms]] is the number of distinct contributions to the
 scattering matrix that constitute the current process.  Each component
 may generate several terms.
 
 The number [[n_mci]] is the number of independent MC
 integration configurations that this process uses.  Distinct process
 components that share a MCI configuration may be combined pointwise.
 (Nevertheless, a given MC variable set may correspond to several
 ``nearby'' kinematical configurations.)  This is also the number of
 distinct sampling-function results that this process can generate.
 Process components that use distinct variable sets are added only once
 after an integration pass has completed.
 
 The [[model]] pointer identifies the physics model and its
 parameters.  This is a pointer to an external object.
 
 The [[rng_factory]] component spawns independent random-number generators for
 use in integration, event generation, and event postprocessing.
 
 Various [[parse_node_t]] objects are taken from the SINDARIN input.
 They encode expressions for evaluating cuts and scales.  The
 workspaces for evaluating those expressions are set up in the
 [[effective_state]] subobjects.  Note that these are really pointers,
 so the actual nodes are not stored inside the process object.
 
 The [[md5sum]] is taken and used to verify the process configuration
 when re-reading data from file.
 <<Process config: public>>=
   public :: process_config_data_t
 <<Process config: types>>=
   type :: process_config_data_t
      integer :: n_in = 0
      integer :: n_components = 0
      integer :: n_terms = 0
      integer :: n_mci = 0
      type(os_data_t) :: os_data
      class(rng_factory_t), allocatable :: rng_factory
      type(string_t) :: model_name
      class(model_data_t), pointer :: model => null ()
      type(qcd_t) :: qcd
      class(expr_factory_t), allocatable :: ef_cuts
      class(expr_factory_t), allocatable :: ef_scale
      class(expr_factory_t), allocatable :: ef_fac_scale
      class(expr_factory_t), allocatable :: ef_ren_scale
      class(expr_factory_t), allocatable :: ef_weight
      character(32) :: md5sum = ""
    contains
    <<Process config: process config data: TBP>>
   end type process_config_data_t
 
 @ %def process_config_data_t
 @ Here, we may compress the expressions for cuts etc.
 <<Process config: process config data: TBP>>=
   procedure :: write => process_config_data_write
 <<Process config: procedures>>=
   subroutine process_config_data_write (config, u, &
        counters, os_data, rng_factory, model, expressions)
     class(process_config_data_t), intent(in) :: config
     integer, intent(in) :: u
     logical, intent(in) :: counters
     logical, intent(in) :: os_data
     logical, intent(in) :: rng_factory
     logical, intent(in) :: model
     logical, intent(in) :: expressions
     write (u, "(1x,A)") "Configuration data:"
     if (counters) then
        write (u, "(3x,A,I0)") "Number of incoming particles = ", &
             config%n_in
        write (u, "(3x,A,I0)") "Number of process components = ", &
             config%n_components
        write (u, "(3x,A,I0)") "Number of process terms      = ", &
             config%n_terms
        write (u, "(3x,A,I0)") "Number of MCI configurations = ", &
             config%n_mci
     end if
     if (os_data) then
        call os_data_write (config%os_data, u)
     end if
     if (associated (config%model)) then
        write (u, "(3x,A,A)")  "Model = ", char (config%model_name)
        if (model) then
           call write_separator (u)
           call config%model%write (u)
           call write_separator (u)
        end if
     else
        write (u, "(3x,A,A,A)")  "Model = ", char (config%model_name), &
             " [not associated]"
     end if
     call config%qcd%write (u, show_md5sum = .false.)
     if (rng_factory) then
        if (allocated (config%rng_factory)) then
           write (u, "(2x)", advance = "no")
           call config%rng_factory%write (u)
        end if
     end if
     call write_separator (u)
     if (expressions) then
        if (allocated (config%ef_cuts)) then
           call write_separator (u)
           write (u, "(3x,A)") "Cut expression:"
           call config%ef_cuts%write (u)
        end if
        if (allocated (config%ef_scale)) then
           call write_separator (u)
           write (u, "(3x,A)") "Scale expression:"
           call config%ef_scale%write (u)
        end if
        if (allocated (config%ef_fac_scale)) then
           call write_separator (u)
           write (u, "(3x,A)") "Factorization scale expression:"
           call config%ef_fac_scale%write (u)
        end if
        if (allocated (config%ef_ren_scale)) then
           call write_separator (u)
           write (u, "(3x,A)") "Renormalization scale expression:"
           call config%ef_ren_scale%write (u)
        end if
        if (allocated (config%ef_weight)) then
           call write_separator (u)
           write (u, "(3x,A)") "Weight expression:"
           call config%ef_weight%write (u)
        end if
     else
        call write_separator (u)
        write (u, "(3x,A)") "Expressions (cut, scales, weight): [not shown]"
     end if
     if (config%md5sum /= "") then
        call write_separator (u)
        write (u, "(3x,A,A,A)")  "MD5 sum (config)  = '", config%md5sum, "'"
     end if
   end subroutine process_config_data_write
 
 @ %def process_config_data_write
 @ Initialize.  We use information from the process metadata and from
 the process library, given the process ID.  We also store the
 currently active OS data set.
 
 The model that we import here should be an instance of the global model.  If we
 create the instance outside, we can make it an extension of the basic
 [[model_data_t]].  This will allow us to synchronize the variable list with
 the model.  Using a pointer instead of an allocatable, we can guarantee the
 [[target]] attribute.
 
 The RNG factory object is imported by moving the allocation.
 <<Process config: process config data: TBP>>=
   procedure :: init => process_config_data_init
 <<Process config: procedures>>=
   subroutine process_config_data_init &
        (config, meta, os_data, qcd, rng_factory, model)
     class(process_config_data_t), intent(out) :: config
     type(process_metadata_t), intent(in) :: meta
     type(os_data_t), intent(in) :: os_data
     type(qcd_t), intent(in) :: qcd
     class(rng_factory_t), intent(inout), allocatable :: rng_factory
     class(model_data_t), intent(inout), pointer :: model
     config%n_in = meta%lib%get_n_in (meta%id)
     config%n_components = size (meta%component_id)
     config%os_data = os_data
     config%qcd = qcd
     call move_alloc (from = rng_factory, to = config%rng_factory)
     config%model_name = model%get_name ()
     config%model => model
     model => null ()
   end subroutine process_config_data_init
 
 @ %def process_config_data_init
 @ Since the captured model is a separate object allocated via a
 pointer, we need a finalizer.
 <<Process config: process config data: TBP>>=
   procedure :: final => process_config_data_final
 <<Process config: procedures>>=
   subroutine process_config_data_final (config)
     class(process_config_data_t), intent(inout) :: config
     if (associated (config%model)) then
        call config%model%final ()
        deallocate (config%model)
     end if
   end subroutine process_config_data_final
 
 @ %def process_config_data_final
 @ Compute the MD5 sum of the configuration data.  This encodes, in
 particular, the model and the expressions for cut, scales, weight,
 etc.  It should not contain the IDs and number of components, etc.,
 since the MD5 sum should be useful for integrating individual
 components.
 
 This is done only once.  If the MD5 sum is nonempty, the calculation
 is skipped.
 <<Process config: process config data: TBP>>=
   procedure :: compute_md5sum => process_config_data_compute_md5sum
 <<Process config: procedures>>=
   subroutine process_config_data_compute_md5sum (config)
     class(process_config_data_t), intent(inout) :: config
     integer :: u
     if (config%md5sum == "") then
        u = free_unit ()
        open (u, status = "scratch", action = "readwrite")
        call config%write (u, counters = .false., os_data = .false., &
             rng_factory = .false., model = .true., expressions = .true.)
        rewind (u)
        config%md5sum = md5sum (u)
        close (u)
     end if
   end subroutine process_config_data_compute_md5sum
 
 @ %def process_config_data_compute_md5sum
 @
 <<Process config: process config data: TBP>>=
   procedure :: get_md5sum => process_config_data_get_md5sum
 <<Process config: procedures>>=
   pure function process_config_data_get_md5sum (config) result (md5)
     character(32) :: md5
     class(process_config_data_t), intent(in) :: config
     md5 = config%md5sum
   end function process_config_data_get_md5sum
 
 @ %def process_config_data_get_md5sum
 @
 \subsection{Metadata}
 This information describes the process and its environment.  It is
 fixed upon initialization.
 
 The [[id]] string is the name of the process object, as given by the
 user.  The matrix element generator will use this string for naming
 Fortran procedures and types, so it should qualify as a Fortran name.
 
 The [[num_id]] is meaningful if nonzero.  It is used for communication
 with external programs or file standards which do not support string IDs.
 
 The [[run_id]] string distinguishes among several runs for the same
 process.  It identifies process instances with respect to adapted
 integration grids and similar run-specific data.  The run ID is kept
 when copying processes for creating instances, however, so it does not
 distinguish event samples.
 
 The [[var_list]] is a snapshot of the variable list, taken at the
 point where the process was initialized.
 
 The [[lib]] pointer accesses the process library where the process
 definition and the process driver are located.
 
 The [[lib_index]] is the index of entry in the process library that
 corresponds to the current process.
 
 The [[component_id]] array identifies the individual process components.
 
 The [[component_description]] is an array of human-readable strings
 that characterize the process components, for instance [[a, b => c, d]].
 
 The [[active]] mask array marks those components which are active.  The others
 are skipped.
 <<Process config: public>>=
   public :: process_metadata_t
 <<Process config: types>>=
   type :: process_metadata_t
      integer :: type = PRC_UNKNOWN
      type(string_t) :: id
      integer :: num_id = 0
      type(string_t) :: run_id
      type(var_list_t) :: var_list
      type(process_library_t), pointer :: lib => null ()
      integer :: lib_update_counter = 0
      integer :: lib_index = 0
      integer :: n_components = 0
      type(string_t), dimension(:), allocatable :: component_id
      type(string_t), dimension(:), allocatable :: component_description
      logical, dimension(:), allocatable :: active
    contains
    <<Process config: process metadata: TBP>>
   end type process_metadata_t
 
 @ %def process_metadata_t
 @ The local var list is a snapshot and needs a finalizer.
 <<Process config: process metadata: TBP>>=
   procedure :: final => process_metadata_final
 <<Process config: procedures>>=
   subroutine process_metadata_final (meta)
     class(process_metadata_t), intent(inout) :: meta
     call meta%var_list%final (follow_link=.true.)
   end subroutine process_metadata_final
 
 @ %def process_metadata_final
 @ Output: ID and run ID.
 We write the variable list only upon request.
 <<Process config: process metadata: TBP>>=
   procedure :: write => process_metadata_write
 <<Process config: procedures>>=
   subroutine process_metadata_write (meta, u, var_list, screen)
     class(process_metadata_t), intent(in) :: meta
     integer, intent(in) :: u
     logical, intent(in) :: var_list, screen
     integer :: i
     select case (meta%type)
     case (PRC_UNKNOWN)
        if (screen) then
           write (msg_buffer, "(A)") "Process [undefined]"
        else
           write (u, "(1x,A)") "Process [undefined]"
        end if
        return
     case (PRC_DECAY)
        if (screen) then
           write (msg_buffer, "(A,1x,A,A,A)") "Process [decay]:", &
                "'", char (meta%id), "'"
        else
           write (u, "(1x,A)", advance="no") "Process [decay]:"
        end if
     case (PRC_SCATTERING)
        if (screen) then
           write (msg_buffer, "(A,1x,A,A,A)") "Process [scattering]:", &
                "'", char (meta%id), "'"
        else
           write (u, "(1x,A)", advance="no") "Process [scattering]:"
        end if
     case default
        call msg_bug ("process_write: undefined process type")
     end select
     if (screen)  then
        call msg_message ()
     else
        write (u, "(1x,A,A,A)") "'", char (meta%id), "'"
     end if
     if (meta%num_id /= 0) then
        if (screen) then
           write (msg_buffer, "(2x,A,I0)") "ID (num)      = ", meta%num_id
           call msg_message ()
        else
           write (u, "(3x,A,I0)") "ID (num)      = ", meta%num_id
        end if
     end if
     if (screen) then
        if (meta%run_id /= "") then
           write (msg_buffer, "(2x,A,A,A)") "Run ID        = '", &
                char (meta%run_id), "'"
           call msg_message ()
        end if
     else
        write (u, "(3x,A,A,A)") "Run ID        = '", char (meta%run_id), "'"
     end if
     if (associated (meta%lib)) then
        if (screen) then
           write (msg_buffer, "(2x,A,A,A)")  "Library name  = '", &
                char (meta%lib%get_name ()), "'"
           call msg_message ()
        else
           write (u, "(3x,A,A,A)")  "Library name  = '", &
                char (meta%lib%get_name ()), "'"
        end if
     else
        if (screen) then
           write (msg_buffer, "(2x,A)")  "Library name  = [not associated]"
           call msg_message ()
        else
           write (u, "(3x,A)")  "Library name  = [not associated]"
        end if
     end if
     if (screen) then
        write (msg_buffer, "(2x,A,I0)")  "Process index = ", meta%lib_index
        call msg_message ()
     else
        write (u, "(3x,A,I0)")  "Process index = ", meta%lib_index
     end if
     if (allocated (meta%component_id)) then
        if (screen) then
           if (any (meta%active)) then
              write (msg_buffer, "(2x,A)")  "Process components:"
           else
              write (msg_buffer, "(2x,A)")  "Process components: [none]"
           end if
           call msg_message ()
        else
           write (u, "(3x,A)")  "Process components:"
        end if
        do i = 1, size (meta%component_id)
           if (.not. meta%active(i))  cycle
           if (screen) then
              write (msg_buffer, "(4x,I0,9A)")  i, ": '", &
                   char (meta%component_id (i)), "':   ", &
                   char (meta%component_description (i))
              call msg_message ()
           else
              write (u, "(5x,I0,9A)")  i, ": '", &
                   char (meta%component_id (i)), "':   ", &
                   char (meta%component_description (i))
           end if
        end do
     end if
     if (screen) then
        write (msg_buffer, "(A)")  repeat ("-", 72)
        call msg_message ()
     else
        call write_separator (u)
     end if
     if (screen)  return
     if (var_list) then
        write (u, "(1x,A)")  "Variable list:"
        call write_separator (u)
        call var_list_write (meta%var_list, u)
     else
        write (u, "(1x,A)")  "Variable list: [not shown]"
     end if
   end subroutine process_metadata_write
 
 @ %def process_metadata_write
 @ Short output: list components.
 <<Process config: process metadata: TBP>>=
   procedure :: show => process_metadata_show
 <<Process config: procedures>>=
   subroutine process_metadata_show (meta, u, model_name)
     class(process_metadata_t), intent(in) :: meta
     integer, intent(in) :: u
     type(string_t), intent(in) :: model_name
     integer :: i
     select case (meta%type)
     case (PRC_UNKNOWN)
        write (u, "(A)") "Process: [undefined]"
        return
     case default
        write (u, "(A)", advance="no") "Process:"
     end select
     write (u, "(1x,A)", advance="no") char (meta%id)
     select case (meta%num_id)
     case (0)
     case default
        write (u, "(1x,'(',I0,')')", advance="no") meta%num_id
     end select
     select case (char (model_name))
     case ("")
     case default
        write (u, "(1x,'[',A,']')", advance="no")  char (model_name)
     end select
     write (u, *)
     if (allocated (meta%component_id)) then
        do i = 1, size (meta%component_id)
           if (meta%active(i)) then
              write (u, "(2x,I0,':',1x,A)")  i, &
                   char (meta%component_description (i))
           end if
        end do
     end if
   end subroutine process_metadata_show
 
 @ %def process_metadata_show
 @ Initialize.
 <<Process config: process metadata: TBP>>=
   procedure :: init => process_metadata_init
 <<Process config: procedures>>=
   subroutine process_metadata_init (meta, id, run_id, lib)
     class(process_metadata_t), intent(out) :: meta
     type(string_t), intent(in) :: id
     type(string_t), intent(in) :: run_id
     type(process_library_t), intent(in), target :: lib
     select case (lib%get_n_in (id))
     case (1);  meta%type = PRC_DECAY
     case (2);  meta%type = PRC_SCATTERING
     case default
        call msg_bug ("Process '" // char (id) // "': impossible n_in")
     end select
     meta%id = id
     meta%run_id = run_id
     meta%lib => lib
     meta%lib_update_counter = lib%get_update_counter ()
     meta%lib_index = lib%get_entry_index (id)
     meta%num_id = lib%get_num_id (id)
     call lib%get_component_list (id, meta%component_id)
     meta%n_components = size (meta%component_id)
     call lib%get_component_description_list (id, meta%component_description)
     allocate (meta%active (meta%n_components), source = .true.)
   end subroutine process_metadata_init
 
 @ %def process_metadata_init
 @ Mark a component as inactive.
 <<Process config: process metadata: TBP>>=
   procedure :: deactivate_component => process_metadata_deactivate_component
 <<Process config: procedures>>=
   subroutine process_metadata_deactivate_component (meta, i)
     class(process_metadata_t), intent(inout) :: meta
     integer, intent(in) :: i
     call msg_message ("Process component '" &
          // char (meta%component_id(i)) // "': matrix element vanishes")
     meta%active(i) = .false.
   end subroutine process_metadata_deactivate_component
 
 @ %def process_metadata_deactivate_component
 @
 \subsection{Beam configuration}
 The object [[data]] holds all details about the initial beam
 configuration.  The allocatable array [[sf]] holds the structure-function
 configuration blocks.  There are [[n_strfun]] entries in the
 structure-function chain (not counting the initial beam object).  We
 maintain [[n_channel]] independent parameterizations of this chain.
 If this is greater than zero, we need a multi-channel sampling
 algorithm, where for each point one channel is selected to generate
 kinematics.
 
 The number of parameters that are required for generating a
 structure-function chain is [[n_sfpar]].
 
 The flag [[azimuthal_dependence]] tells whether the process setup is
 symmetric about the beam axis in the c.m.\ system.  This implies that
 there is no transversal beam polarization.  The flag [[lab_is_cm_frame]] is
 obvious.
 <<Process config: public>>=
   public :: process_beam_config_t
 <<Process config: types>>=
   type :: process_beam_config_t
      type(beam_data_t) :: data
      integer :: n_strfun = 0
      integer :: n_channel = 1
      integer :: n_sfpar = 0
      type(sf_config_t), dimension(:), allocatable :: sf
      type(sf_channel_t), dimension(:), allocatable :: sf_channel
      logical :: azimuthal_dependence = .false.
      logical :: lab_is_cm_frame = .true.
      character(32) :: md5sum = ""
      logical :: sf_trace = .false.
      type(string_t) :: sf_trace_file
    contains
    <<Process config: process beam config: TBP>>
   end type process_beam_config_t
 
 @ %def process_beam_config_t
 @ Here we write beam data only if they are actually used.
 
 The [[verbose]] flag is passed to the beam-data writer.
 <<Process config: process beam config: TBP>>=
   procedure :: write => process_beam_config_write
 <<Process config: procedures>>=
   subroutine process_beam_config_write (object, unit, verbose)
     class(process_beam_config_t), intent(in) :: object
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose
     integer :: u, i, c
     u = given_output_unit (unit)
     call object%data%write (u, verbose = verbose)
     if (object%data%initialized) then
        write (u, "(3x,A,L1)")  "Azimuthal dependence    = ", &
             object%azimuthal_dependence
        write (u, "(3x,A,L1)")  "Lab frame is c.m. frame = ", &
             object%lab_is_cm_frame
        if (object%md5sum /= "") then
           write (u, "(3x,A,A,A)")  "MD5 sum (beams/strf) = '", &
                object%md5sum, "'"
        end if
        if (allocated (object%sf)) then
           do i = 1, size (object%sf)
              call object%sf(i)%write (u)
           end do
           if (any_sf_channel_has_mapping (object%sf_channel)) then
              write (u, "(1x,A,L1)")  "Structure-function mappings per channel:"
              do c = 1, object%n_channel
                 write (u, "(3x,I0,':')", advance="no")  c
                 call object%sf_channel(c)%write (u)
              end do
           end if
        end if
     end if
   end subroutine process_beam_config_write
 
 @ %def process_beam_config_write
 @ The beam data have a finalizer.  We assume that there is none for the
 structure-function data.
 <<Process config: process beam config: TBP>>=
   procedure :: final => process_beam_config_final
 <<Process config: procedures>>=
   subroutine process_beam_config_final (object)
     class(process_beam_config_t), intent(inout) :: object
     call object%data%final ()
   end subroutine process_beam_config_final
 
 @ %def process_beam_config_final
 @ Initialize the beam setup with a given beam structure object.
 <<Process config: process beam config: TBP>>=
   procedure :: init_beam_structure => process_beam_config_init_beam_structure
 <<Process config: procedures>>=
   subroutine process_beam_config_init_beam_structure &
        (beam_config, beam_structure, sqrts, model, decay_rest_frame)
     class(process_beam_config_t), intent(out) :: beam_config
     type(beam_structure_t), intent(in) :: beam_structure
     logical, intent(in), optional :: decay_rest_frame
     real(default), intent(in) :: sqrts
     class(model_data_t), intent(in), target :: model
     call beam_config%data%init_structure (beam_structure, &
          sqrts, model, decay_rest_frame)
     beam_config%lab_is_cm_frame = beam_config%data%cm_frame ()
   end subroutine process_beam_config_init_beam_structure
 
 @ %def process_beam_config_init_beam_structure
 @ Initialize the beam setup for a scattering process with specified
 flavor combination, other properties taken from the beam structure
 object (if any).
 <<Process config: process beam config: TBP>>=
   procedure :: init_scattering => process_beam_config_init_scattering
 <<Process config: procedures>>=
   subroutine process_beam_config_init_scattering &
        (beam_config, flv_in, sqrts, beam_structure)
     class(process_beam_config_t), intent(out) :: beam_config
     type(flavor_t), dimension(2), intent(in) :: flv_in
     real(default), intent(in) :: sqrts
     type(beam_structure_t), intent(in), optional :: beam_structure
     if (present (beam_structure)) then
        if (beam_structure%polarized ()) then
           call beam_config%data%init_sqrts (sqrts, flv_in, &
                beam_structure%get_smatrix (), beam_structure%get_pol_f ())
        else
           call beam_config%data%init_sqrts (sqrts, flv_in)
        end if
     else
        call beam_config%data%init_sqrts (sqrts, flv_in)
     end if
   end subroutine process_beam_config_init_scattering
 
 @ %def process_beam_config_init_scattering
 @ Initialize the beam setup for a decay process with specified flavor,
 other properties taken from the beam structure object (if present).
 
 For a cascade decay, we set
 [[rest_frame]] to false, indicating a event-wise varying momentum.
 The beam data itself are initialized for the particle at rest.
 <<Process config: process beam config: TBP>>=
   procedure :: init_decay => process_beam_config_init_decay
 <<Process config: procedures>>=
   subroutine process_beam_config_init_decay &
        (beam_config, flv_in, rest_frame, beam_structure)
     class(process_beam_config_t), intent(out) :: beam_config
     type(flavor_t), dimension(1), intent(in) :: flv_in
     logical, intent(in), optional :: rest_frame
     type(beam_structure_t), intent(in), optional :: beam_structure
     if (present (beam_structure)) then
        if (beam_structure%polarized ()) then
           call beam_config%data%init_decay (flv_in, &
                beam_structure%get_smatrix (), beam_structure%get_pol_f (), &
                rest_frame = rest_frame)
        else
           call beam_config%data%init_decay (flv_in, rest_frame = rest_frame)
        end if
     else
        call beam_config%data%init_decay (flv_in, &
             rest_frame = rest_frame)
     end if
     beam_config%lab_is_cm_frame = beam_config%data%cm_frame ()
   end subroutine process_beam_config_init_decay
 
 @ %def process_beam_config_init_decay
 @ Print an informative message.
 <<Process config: process beam config: TBP>>=
   procedure :: startup_message => process_beam_config_startup_message
 <<Process config: procedures>>=
   subroutine process_beam_config_startup_message &
        (beam_config, unit, beam_structure)
     class(process_beam_config_t), intent(in) :: beam_config
     integer, intent(in), optional :: unit
     type(beam_structure_t), intent(in), optional :: beam_structure
     integer :: u
     u = free_unit ()
     open (u, status="scratch", action="readwrite")
     if (present (beam_structure)) then
        call beam_structure%write (u)
     end if
     call beam_config%data%write (u)
     rewind (u)
     do
        read (u, "(1x,A)", end=1)  msg_buffer
        call msg_message ()
     end do
 1   continue
     close (u)
   end subroutine process_beam_config_startup_message
 
 @ %def process_beam_config_startup_message
 @ Allocate the structure-function array.
 <<Process config: process beam config: TBP>>=
   procedure :: init_sf_chain => process_beam_config_init_sf_chain
 <<Process config: procedures>>=
   subroutine process_beam_config_init_sf_chain &
        (beam_config, sf_config, sf_trace_file)
     class(process_beam_config_t), intent(inout) :: beam_config
     type(sf_config_t), dimension(:), intent(in) :: sf_config
     type(string_t), intent(in), optional :: sf_trace_file
     integer :: i
     beam_config%n_strfun = size (sf_config)
     allocate (beam_config%sf (beam_config%n_strfun))
     do i = 1, beam_config%n_strfun
        associate (sf => sf_config(i))
          call beam_config%sf(i)%init (sf%i, sf%data)
          if (.not. sf%data%is_generator ()) then
             beam_config%n_sfpar = beam_config%n_sfpar + sf%data%get_n_par ()
          end if
        end associate
     end do
     if (present (sf_trace_file)) then
        beam_config%sf_trace = .true.
        beam_config%sf_trace_file = sf_trace_file
     end if
   end subroutine process_beam_config_init_sf_chain
 
 @ %def process_beam_config_init_sf_chain
 @ Allocate the structure-function mapping channel array, given the
 requested number of channels.
 <<Process config: process beam config: TBP>>=
   procedure :: allocate_sf_channels => process_beam_config_allocate_sf_channels
 <<Process config: procedures>>=
   subroutine process_beam_config_allocate_sf_channels (beam_config, n_channel)
     class(process_beam_config_t), intent(inout) :: beam_config
     integer, intent(in) :: n_channel
     beam_config%n_channel = n_channel
     call allocate_sf_channels (beam_config%sf_channel, &
          n_channel = n_channel, &
          n_strfun = beam_config%n_strfun)
   end subroutine process_beam_config_allocate_sf_channels
 
 @ %def process_beam_config_allocate_sf_channels
 @ Set a structure-function mapping channel for an array of
 structure-function entries, for a single channel.  (The default is no mapping.)
 <<Process config: process beam config: TBP>>=
   procedure :: set_sf_channel => process_beam_config_set_sf_channel
 <<Process config: procedures>>=
   subroutine process_beam_config_set_sf_channel (beam_config, c, sf_channel)
     class(process_beam_config_t), intent(inout) :: beam_config
     integer, intent(in) :: c
     type(sf_channel_t), intent(in) :: sf_channel
     beam_config%sf_channel(c) = sf_channel
   end subroutine process_beam_config_set_sf_channel
 
 @ %def process_beam_config_set_sf_channel
 @ Print an informative startup message.
 <<Process config: process beam config: TBP>>=
   procedure :: sf_startup_message => process_beam_config_sf_startup_message
 <<Process config: procedures>>=
   subroutine process_beam_config_sf_startup_message &
        (beam_config, sf_string, unit)
     class(process_beam_config_t), intent(in) :: beam_config
     type(string_t), intent(in) :: sf_string
     integer, intent(in), optional :: unit
     if (beam_config%n_strfun > 0) then
        call msg_message ("Beam structure: " // char (sf_string), unit = unit)
        write (msg_buffer, "(A,3(1x,I0,1x,A))") &
             "Beam structure:", &
             beam_config%n_channel, "channels,", &
             beam_config%n_sfpar, "dimensions"
        call msg_message (unit = unit)
        if (beam_config%sf_trace) then
           call msg_message ("Beam structure: tracing &
                &values in '" // char (beam_config%sf_trace_file) // "'")
        end if
     end if
   end subroutine process_beam_config_sf_startup_message
 
 @ %def process_beam_config_startup_message
 @ Return the PDF set currently in use, if any.  This should be unique,
 so we scan the structure functions until we get a nonzero number.
 
 (This implies that if the PDF set is not unique (e.g., proton and
 photon structure used together), this doesn't work correctly.)
 <<Process config: process beam config: TBP>>=
   procedure :: get_pdf_set => process_beam_config_get_pdf_set
 <<Process config: procedures>>=
   function process_beam_config_get_pdf_set (beam_config) result (pdf_set)
     class(process_beam_config_t), intent(in) :: beam_config
     integer :: pdf_set
     integer :: i
     pdf_set = 0
     if (allocated (beam_config%sf)) then
        do i = 1, size (beam_config%sf)
           pdf_set = beam_config%sf(i)%get_pdf_set ()
           if (pdf_set /= 0)  return
        end do
     end if
   end function process_beam_config_get_pdf_set
 
 @ %def process_beam_config_get_pdf_set
 @ Return the beam file.
 <<Process config: process beam config: TBP>>=
   procedure :: get_beam_file => process_beam_config_get_beam_file
 <<Process config: procedures>>=
   function process_beam_config_get_beam_file (beam_config) result (file)
     class(process_beam_config_t), intent(in) :: beam_config
     type(string_t) :: file
     integer :: i
     file = ""
     if (allocated (beam_config%sf)) then
        do i = 1, size (beam_config%sf)
           file = beam_config%sf(i)%get_beam_file ()
           if (file /= "")  return
        end do
     end if
   end function process_beam_config_get_beam_file
 
 @ %def process_beam_config_get_beam_file
 @ Compute the MD5 sum for the complete beam setup.  We rely on the
 default output of [[write]] to contain all relevant data.
 
 This is done only once, when the MD5 sum is still empty.
 <<Process config: process beam config: TBP>>=
   procedure :: compute_md5sum => process_beam_config_compute_md5sum
 <<Process config: procedures>>=
   subroutine process_beam_config_compute_md5sum (beam_config)
     class(process_beam_config_t), intent(inout) :: beam_config
     integer :: u
     if (beam_config%md5sum == "") then
        u = free_unit ()
        open (u, status = "scratch", action = "readwrite")
        call beam_config%write (u, verbose=.true.)
        rewind (u)
        beam_config%md5sum = md5sum (u)
        close (u)
     end if
   end subroutine process_beam_config_compute_md5sum
 
 @ %def process_beam_config_compute_md5sum
 @
 <<Process config: process beam config: TBP>>=
   procedure :: get_md5sum => process_beam_config_get_md5sum
 <<Process config: procedures>>=
   pure function process_beam_config_get_md5sum (beam_config) result (md5)
     character(32) :: md5
     class(process_beam_config_t), intent(in) :: beam_config
     md5 = beam_config%md5sum
   end function process_beam_config_get_md5sum
 
 @ %def process_beam_config_get_md5sum
 @
 <<Process config: process beam config: TBP>>=
   procedure :: has_structure_function => process_beam_config_has_structure_function
 <<Process config: procedures>>=
   pure function process_beam_config_has_structure_function (beam_config) result (has_sf)
     logical :: has_sf
     class(process_beam_config_t), intent(in) :: beam_config
     has_sf = beam_config%n_strfun > 0
   end function process_beam_config_has_structure_function
 
 @ %def process_beam_config_has_structure_function
 @
 \subsection{Process components}
 A process component is an individual contribution to a process
 (scattering or decay) which needs not be physical.  The sum over all
 components should be physical.
 
 The [[index]] indentifies this component within its parent process.
 
 The actual process component is stored in the [[core]] subobject.  We
 use a polymorphic subobject instead of an extension of
 [[process_component_t]], because the individual entries in the array
 of process components can have different types.  In short,
 [[process_component_t]] is a wrapper for the actual process variants.
 
 If the [[active]] flag is false, we should skip this component.  This happens
 if the associated process has vanishing matrix element.
 
 The index array [[i_term]] points to the individual terms generated by
 this component.  The indices refer to the parent process.
 
 The index [[i_mci]] is the index of the MC integrator and parameter set which
 are associated to this process component.
 <<Process config: public>>=
   public :: process_component_t
 <<Process config: types>>=
   type :: process_component_t
      type(process_component_def_t), pointer :: config => null ()
      integer :: index = 0
      logical :: active = .false.
      class(mci_t), allocatable :: mci_template
      integer, dimension(:), allocatable :: i_term
      integer :: i_mci = 0
      class(phs_config_t), allocatable :: phs_config
      character(32) :: md5sum_phs = ""
      integer :: component_type = COMP_DEFAULT
    contains
    <<Process config: process component: TBP>>
   end type process_component_t
 
 @ %def process_component_t
 @ Finalizer.  The MCI template may (potentially) need a finalizer.  The process
 configuration finalizer may include closing an open scratch file.
 <<Process config: process component: TBP>>=
   procedure :: final => process_component_final
 <<Process config: procedures>>=
   subroutine process_component_final (object)
     class(process_component_t), intent(inout) :: object
     if (allocated (object%mci_template)) then
        call object%mci_template%final ()
     end if
     if (allocated (object%phs_config)) then
        call object%phs_config%final ()
     end if
   end subroutine process_component_final
 
 @ %def process_component_final
 @ The meaning of [[verbose]] depends on the process variant.
 <<Process config: process component: TBP>>=
   procedure :: write => process_component_write
 <<Process config: procedures>>=
   subroutine process_component_write (object, unit)
     class(process_component_t), intent(in) :: object
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     if (associated (object%config)) then
        write (u, "(1x,A,I0)")  "Component #", object%index
        call object%config%write (u)
        if (object%md5sum_phs /= "") then
           write (u, "(3x,A,A,A)")  "MD5 sum (phs)       = '", &
                object%md5sum_phs, "'"
        end if
     else
        write (u, "(1x,A)") "Process component: [not allocated]"
     end if
     if (.not. object%active) then
        write (u, "(1x,A)") "[Inactive]"
        return
     end if
     write (u, "(1x,A)") "Referenced data:"
     if (allocated (object%i_term)) then
        write (u, "(3x,A,999(1x,I0))") "Terms                    =", &
             object%i_term
     else
        write (u, "(3x,A)") "Terms                    = [undefined]"
     end if
     if (object%i_mci /= 0) then
        write (u, "(3x,A,I0)") "MC dataset               = ", object%i_mci
     else
        write (u, "(3x,A)") "MC dataset               = [undefined]"
     end if
     if (allocated (object%phs_config)) then
        call object%phs_config%write (u)
     end if
   end subroutine process_component_write
 
 @ %def process_component_write
 @ Initialize the component.
 
 WK 2018-04-05: the call to [[set_component_index]] appears to be redundant,
 disabled.
 <<Process config: process component: TBP>>=
   procedure :: init => process_component_init
 <<Process config: procedures>>=
   subroutine process_component_init (component, &
        i_component, meta, config, &
        active, data, &
        mci_template, phs_config_template)
     class(process_component_t), intent(out) :: component
     integer, intent(in) :: i_component
     type(process_metadata_t), intent(in), target :: meta
     type(process_config_data_t), intent(in) :: config
     logical, intent(in) :: active
     type(process_constants_t), intent(in) :: data
     class(mci_t), intent(in), allocatable :: mci_template
     class(phs_config_t), intent(in), allocatable :: phs_config_template
 
     component%index = i_component
     component%config => meta%lib%get_component_def_ptr (meta%id, i_component)
 
     component%active = active
     if (component%active) then
        if (allocated (mci_template)) &
           allocate (component%mci_template, source = mci_template)
        allocate (component%phs_config, source = phs_config_template)
        call component%phs_config%init (data, config%model)
        !!! call component%phs_config%set_component_index (component%index)
     end if
   end subroutine process_component_init
 
 @ %def process_component_init
 @
 <<Process config: process component: TBP>>=
   procedure :: is_active => process_component_is_active
 <<Process config: procedures>>=
   elemental function process_component_is_active (component) result (active)
     logical :: active
     class(process_component_t), intent(in) :: component
     active = component%active
   end function process_component_is_active
 
 @ %def process_component_is_active
 @
 <<Process config: process component: TBP>>=
   procedure :: has_mci_template => process_component_has_mci_template
 <<Process config: procedures>>=
   pure function process_component_has_mci_template (component) &
          result (is_allocated)
     logical :: is_allocated
     class(process_component_t), intent(in) :: component
     is_allocated = allocated (component%mci_template)
   end function process_component_has_mci_template
 
 @ %def process_component_has_mci_template
 @
 <<Process config: process component: TBP>>=
   procedure :: extract_mci_template => process_component_extract_mci_template
 <<Process config: procedures>>=
   function process_component_extract_mci_template (component) &
          result (mci_template)
     class(mci_t), allocatable :: mci_template
     class(process_component_t), intent(in) :: component
     if (allocated (component%mci_template)) &
        allocate (mci_template, source = component%mci_template)
   end function process_component_extract_mci_template
 
 @ %def process_component_extract_mci_template
 @ Finalize the phase-space configuration.
 <<Process config: process component: TBP>>=
   procedure :: configure_phs => process_component_configure_phs
 <<Process config: procedures>>=
   subroutine process_component_configure_phs &
        (component, sqrts, beam_config, rebuild, &
         ignore_mismatch, subdir)
     class(process_component_t), intent(inout) :: component
     real(default), intent(in) :: sqrts
     type(process_beam_config_t), intent(in) :: beam_config
     logical, intent(in), optional :: rebuild
     logical, intent(in), optional :: ignore_mismatch
     type(string_t), intent(in), optional :: subdir
     logical :: no_strfun
     integer :: nlo_type
     no_strfun = beam_config%n_strfun == 0
     nlo_type = component%config%get_nlo_type ()
     call component%phs_config%configure (sqrts, &
          azimuthal_dependence = beam_config%azimuthal_dependence, &
          sqrts_fixed = no_strfun, &
          cm_frame = beam_config%lab_is_cm_frame .and. no_strfun, &
          rebuild = rebuild, ignore_mismatch = ignore_mismatch, &
          nlo_type = nlo_type, &
          subdir = subdir)
   end subroutine process_component_configure_phs
 
 @ %def process_component_configure_phs
 @ The process component possesses two MD5 sums: the checksum of the
 component definition, which should be available when the component is
 initialized, and the phase-space MD5 sum, which is available after
 configuration.
 <<Process config: process component: TBP>>=
   procedure :: compute_md5sum => process_component_compute_md5sum
 <<Process config: procedures>>=
   subroutine process_component_compute_md5sum (component)
     class(process_component_t), intent(inout) :: component
     component%md5sum_phs = component%phs_config%get_md5sum ()
   end subroutine process_component_compute_md5sum
 
 @ %def process_component_compute_md5sum
 @ Match phase-space channels with structure-function channels, where
 applicable.
 
 This calls a method of the [[phs_config]] phase-space implementation.
 <<Process config: process component: TBP>>=
   procedure :: collect_channels => process_component_collect_channels
 <<Process config: procedures>>=
   subroutine process_component_collect_channels (component, coll)
     class(process_component_t), intent(inout) :: component
     type(phs_channel_collection_t), intent(inout) :: coll
     call component%phs_config%collect_channels (coll)
   end subroutine process_component_collect_channels
 
 @ %def process_component_collect_channels
 @
 <<Process config: process component: TBP>>=
   procedure :: get_config => process_component_get_config
 <<Process config: procedures>>=
   function process_component_get_config (component) &
          result (config)
     type(process_component_def_t) :: config
     class(process_component_t), intent(in) :: component
     config = component%config
   end function process_component_get_config
 
 @ %def process_component_get_config
 @
 <<Process config: process component: TBP>>=
   procedure :: get_md5sum => process_component_get_md5sum
 <<Process config: procedures>>=
   pure function process_component_get_md5sum (component) result (md5)
     type(string_t) :: md5
     class(process_component_t), intent(in) :: component
     md5 = component%config%get_md5sum () // component%md5sum_phs
   end function process_component_get_md5sum
 
 @ %def process_component_get_md5sum
 @ Return the number of phase-space parameters.
 <<Process config: process component: TBP>>=
   procedure :: get_n_phs_par => process_component_get_n_phs_par
 <<Process config: procedures>>=
   function process_component_get_n_phs_par (component) result (n_par)
     class(process_component_t), intent(in) :: component
     integer :: n_par
     n_par = component%phs_config%get_n_par ()
   end function process_component_get_n_phs_par
 
 @ %def process_component_get_n_phs_par
 @
 <<Process config: process component: TBP>>=
   procedure :: get_phs_config => process_component_get_phs_config
 <<Process config: procedures>>=
   subroutine process_component_get_phs_config (component, phs_config)
     class(process_component_t), intent(in), target :: component
     class(phs_config_t), intent(out), pointer :: phs_config
     phs_config => component%phs_config
   end subroutine process_component_get_phs_config
 
 @ %def process_component_get_phs_config
 @
 <<Process config: process component: TBP>>=
   procedure :: get_nlo_type => process_component_get_nlo_type
 <<Process config: procedures>>=
   elemental function process_component_get_nlo_type (component) result (nlo_type)
      integer :: nlo_type
      class(process_component_t), intent(in) :: component
      nlo_type = component%config%get_nlo_type ()
   end function process_component_get_nlo_type
 
 @ %def process_component_get_nlo_type
 @
 <<Process config: process component: TBP>>=
   procedure :: needs_mci_entry => process_component_needs_mci_entry
 <<Process config: procedures>>=
   function process_component_needs_mci_entry (component, combined_integration) result (value)
     logical :: value
     class(process_component_t), intent(in) :: component
     logical, intent(in), optional :: combined_integration
     value = component%active
     if (present (combined_integration)) then
        if (combined_integration) &
             value = value .and. component%component_type <= COMP_MASTER
     end if
   end function process_component_needs_mci_entry
 
 @ %def process_component_needs_mci_entry
 @
 <<Process config: process component: TBP>>=
   procedure :: can_be_integrated => process_component_can_be_integrated
 <<Process config: procedures>>=
   elemental function process_component_can_be_integrated (component) result (active)
     logical :: active
     class(process_component_t), intent(in) :: component
     active = component%config%can_be_integrated ()
   end function process_component_can_be_integrated
 
 @ %def process_component_can_be_integrated
 @
 \subsection{Process terms}
 For straightforward tree-level calculations, each process component
 corresponds to a unique elementary interaction.  However, in the case
 of NLO calculations with subtraction terms, a process component may
 split into several separate contributions to the scattering, which are
 qualified by interactions with distinct kinematics and particle
 content.  We represent their configuration as [[process_term_t]]
 objects, the actual instances will be introduced below as
 [[term_instance_t]].  In any case, the process term contains an
 elementary interaction with a definite quantum-number and momentum
 content.
 
 The index [[i_term_global]] identifies the term relative to the
 process.
 
 The index [[i_component]] identifies the process component which
 generates this term, relative to the parent process.
 
 The index [[i_term]] identifies the term relative to the process
 component (not the process).
 
 The [[data]] subobject holds all process constants.
 
 The number of allowed flavor/helicity/color combinations is stored as
 [[n_allowed]].  This is the total number of independent entries in the
 density matrix.  For each combination, the index of the flavor,
 helicity, and color state is stored in the arrays [[flv]], [[hel]],
 and [[col]], respectively.
 
 The flag [[rearrange]] is true if we need to rearrange the particles of the
 hard interaction, to obtain the effective parton state.
 
 The interaction [[int]] holds the quantum state for the (resolved) hard
 interaction, the parent-child relations of the particles, and their momenta.
 The momenta are not filled yet; this is postponed to copies of [[int]] which
 go into the process instances.
 
 If recombination is in effect, we should allocate [[int_eff]] to describe the
 rearranged partonic state.
 
 This type is public only for use in a unit test.
 <<Process config: public>>=
   public :: process_term_t
 <<Process config: types>>=
   type :: process_term_t
      integer :: i_term_global = 0
      integer :: i_component = 0
      integer :: i_term = 0
      integer :: i_sub = 0
      integer :: i_core = 0
      integer :: n_allowed = 0
      type(process_constants_t) :: data
      real(default) :: alpha_s = 0
      integer, dimension(:), allocatable :: flv, hel, col
      integer :: n_sub, n_sub_color, n_sub_spin
      type(interaction_t) :: int
      type(interaction_t), pointer :: int_eff => null ()
      class(pcm_t), pointer :: pcm => null ()
    contains
    <<Process config: process term: TBP>>
   end type process_term_t
 
 @ %def process_term_t
 @ For the output, we skip the process constants and the tables of
 allowed quantum numbers.  Those can also be read off from the
 interaction object.
 <<Process config: process term: TBP>>=
   procedure :: write => process_term_write
 <<Process config: procedures>>=
   subroutine process_term_write (term, unit)
     class(process_term_t), intent(in) :: term
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A,I0)")  "Term #", term%i_term_global
     write (u, "(3x,A,I0)")  "Process component index      = ", &
          term%i_component
     write (u, "(3x,A,I0)")  "Term index w.r.t. component  = ", &
          term%i_term
     call write_separator (u)
     write (u, "(1x,A)")  "Hard interaction:"
     call write_separator (u)
     call term%int%basic_write (u)
   end subroutine process_term_write
 
 @ %def process_term_write
 @ Write an account of all quantum number states and their current status.
 <<Process config: process term: TBP>>=
   procedure :: write_state_summary => process_term_write_state_summary
 <<Process config: procedures>>=
   subroutine process_term_write_state_summary (term, core, unit)
     class(process_term_t), intent(in) :: term
     class(prc_core_t), intent(in) :: core
     integer, intent(in), optional :: unit
     integer :: u, i, f, h, c
     type(state_iterator_t) :: it
     character :: sgn
     u = given_output_unit (unit)
     write (u, "(1x,A,I0)")  "Term #", term%i_term_global
     call it%init (term%int%get_state_matrix_ptr ())
     do while (it%is_valid ())
        i = it%get_me_index ()
        f = term%flv(i)
        h = term%hel(i)
        if (allocated (term%col)) then
           c = term%col(i)
        else
           c = 1
        end if
        if (core%is_allowed (term%i_term, f, h, c)) then
           sgn = "+"
        else
           sgn = " "
        end if
        write (u, "(1x,A1,1x,I0,2x)", advance="no")  sgn, i
        call quantum_numbers_write (it%get_quantum_numbers (), u)
        write (u, *)
        call it%advance ()
     end do
   end subroutine process_term_write_state_summary
 
 @ %def process_term_write_state_summary
 @ Finalizer: the [[int]] and potentially [[int_eff]] components have a
 finalizer that we must call.
 <<Process config: process term: TBP>>=
   procedure :: final => process_term_final
 <<Process config: procedures>>=
   subroutine process_term_final (term)
     class(process_term_t), intent(inout) :: term
     call term%int%final ()
   end subroutine process_term_final
 
 @ %def process_term_final
 @ Initialize the term.  We copy the process constants from the [[core]]
 object and set up the [[int]] hard interaction accordingly.
 
 The [[alpha_s]] value is useful for writing external event records.  This is
 the constant value which may be overridden by a event-specific running value.
 If the model does not contain the strong coupling, the value is zero.
 
 The [[rearrange]] part is commented out; this or something equivalent
 could become relevant for NLO algorithms.
 <<Process config: process term: TBP>>=
   procedure :: init => process_term_init
 <<Process config: procedures>>=
   subroutine process_term_init &
        (term, i_term_global, i_component, i_term, core, model, &
         nlo_type, use_beam_pol, subtraction_method)
     class(process_term_t), intent(inout), target :: term
     integer, intent(in) :: i_term_global
     integer, intent(in) :: i_component
     integer, intent(in) :: i_term
     class(prc_core_t), intent(inout) :: core
     class(model_data_t), intent(in), target :: model
     integer, intent(in), optional :: nlo_type
     logical, intent(in), optional :: use_beam_pol
     type(string_t), intent(in), optional :: subtraction_method
     class(modelpar_data_t), pointer :: alpha_s_ptr
     logical :: use_internal_color
     term%i_term_global = i_term_global
     term%i_component = i_component
     term%i_term = i_term
     call core%get_constants (term%data, i_term)
     alpha_s_ptr => model%get_par_data_ptr (var_str ("alphas"))
     if (associated (alpha_s_ptr)) then
        term%alpha_s = alpha_s_ptr%get_real ()
     else
        term%alpha_s = -1
     end if
     use_internal_color = .false.
     if (present (subtraction_method)) &
          use_internal_color = (char (subtraction_method) == 'omega') &
          .or. (char (subtraction_method) == 'threshold')
     call term%setup_interaction (core, model, nlo_type = nlo_type, &
          pol_beams = use_beam_pol, use_internal_color = use_internal_color)
   end subroutine process_term_init
 
 @ %def process_term_init
 @ We fetch the process constants which determine the quantum numbers and
 use those to create the interaction.  The interaction contains
 incoming and outgoing particles, no virtuals.  The incoming particles
 are parents of the outgoing ones.
 
 Keeping previous \whizard\ conventions, we invert the color assignment
 (but not flavor or helicity) for the incoming particles.  When the
 color-flow square matrix is evaluated, this inversion is done again,
 so in the color-flow sequence we get the color assignments of the
 matrix element.
 
 \textbf{Why are these four subtraction entries for structure-function
 aware interactions?} Taking the soft or collinear limit of the real-emission
 matrix element, the behavior of the parton energy fractions has to be
 taken into account. In the pure real case, $x_\oplus$ and $x_\ominus$
 are given by
 \begin{equation*}
   x_\oplus = \frac{\bar{x}_\oplus}{\sqrt{1-\xi}}
              \sqrt{\frac{2 - \xi(1-y)}{2 - \xi(1+y)}},
   \quad
   x_\ominus = \frac{\bar{x}_\ominus}{\sqrt{1-\xi}}
              \sqrt{\frac{2 - \xi(1+y)}{2 - \xi(1-y)}}.
 \end{equation*}
 In the soft limit, $\xi \to 0$, this yields $x_\oplus = \bar{x}_\oplus$
 and $x_\ominus = \bar{x}_\ominus$. In the collinear limit, $y \to 1$,
 it is $x_\oplus = \bar{x}_\oplus / (1 - \xi)$ and $x_\ominus = \bar{x}_\ominus$.
 Likewise, in the anti-collinear limit $y \-o -1$, the inverse relation holds.
 We therefore have to distinguish four cases with the PDF assignments
 $f(x_\oplus) \cdot f(x_\ominus)$, $f(\bar{x}_\oplus) \cdot f(\bar{x}_\ominus)$,
 $f\left(\bar{x}_\oplus / (1-\xi)\right) \cdot f(\bar{x}_\ominus)$ and
 $f(\bar{x}_\oplus) \cdot f\left(\bar{x}_\ominus / (1-\xi)\right)$.
 
 <<Process config: process term: TBP>>=
   procedure :: setup_interaction => process_term_setup_interaction
 <<Process config: procedures>>=
   subroutine process_term_setup_interaction (term, core, model, &
      nlo_type, pol_beams, use_internal_color)
     class(process_term_t), intent(inout) :: term
     class(prc_core_t), intent(inout) :: core
     class(model_data_t), intent(in), target :: model
     logical, intent(in), optional :: pol_beams
     integer, intent(in), optional :: nlo_type
     logical, intent(in), optional :: use_internal_color
     integer :: n, n_tot
     type(flavor_t), dimension(:), allocatable :: flv
     type(color_t), dimension(:), allocatable :: col
     type(helicity_t), dimension(:), allocatable :: hel
     type(quantum_numbers_t), dimension(:), allocatable :: qn
     logical :: is_pol, use_color
     integer :: nlo_t, n_sub
     is_pol = .false.; if (present (pol_beams)) is_pol = pol_beams
     nlo_t = BORN; if (present (nlo_type)) nlo_t = nlo_type
     n_tot = term%data%n_in + term%data%n_out
     call count_number_of_states ()
     term%n_allowed = n
     call compute_n_sub ()
     call fill_quantum_numbers ()
     call term%int%basic_init &
          (term%data%n_in, 0, term%data%n_out, set_relations = .true.)
     select type (core)
     type is (prc_openloops_t)
        call setup_states_openloops ()
     type is (prc_threshold_t)
        call setup_states_threshold ()
     class is (prc_user_defined_base_t)
        call setup_states_other_user_defined ()
     class default
        call setup_states_omega ()
     end select
     call term%int%freeze ()
   contains
     subroutine count_number_of_states ()
       integer :: f, h, c
       n = 0
       select type (core)
       class is (prc_user_defined_base_t)
          do f = 1, term%data%n_flv
             do h = 1, term%data%n_hel
                do c = 1, term%data%n_col
                   n = n + 1
                end do
             end do
          end do
       class default !!! Omega and all test cores
          do f = 1, term%data%n_flv
             do h = 1, term%data%n_hel
                do c = 1, term%data%n_col
                   if (core%is_allowed (term%i_term, f, h, c))  n = n + 1
                end do
             end do
          end do
       end select
     end subroutine count_number_of_states
 
     subroutine compute_n_sub ()
       logical :: can_have_sub
       integer :: n_sub_color, n_sub_spin
       use_color = .false.; if (present (use_internal_color)) &
            use_color = use_internal_color
       can_have_sub = nlo_t == NLO_VIRTUAL .or. &
            (nlo_t == NLO_REAL .and. term%i_term_global == term%i_sub) .or. &
            nlo_t == NLO_MISMATCH
       n_sub_color = 0; n_sub_spin = 0
       if (can_have_sub) then
          if (.not. use_color) n_sub_color = n_tot * (n_tot - 1) / 2
          if (nlo_t == NLO_REAL) then
             select type (pcm_nlo => term%pcm)
             class is (pcm_nlo_t)
                if (pcm_nlo%region_data%requires_spin_correlations ()) &
                     n_sub_spin = 16 * pcm_nlo%region_data%n_emitters
             end select
          end if
       end if
       n_sub = n_sub_color + n_sub_spin
       !!! For the virtual subtraction we also need the finite virtual contribution
       !!! corresponding to the $\epsilon^0$-pole
       if (nlo_t == NLO_VIRTUAL)  n_sub = n_sub + 1
       if (associated (term%pcm)) then
          if (term%pcm%has_pdfs .and. ((nlo_t == NLO_REAL .and. can_have_sub) &
               .or. nlo_t == NLO_DGLAP)) n_sub = n_sub + n_beam_structure_int
       end if
       term%n_sub = n_sub
       term%n_sub_color = n_sub_color
       term%n_sub_spin = n_sub_spin
     end subroutine compute_n_sub
 
     subroutine fill_quantum_numbers ()
       integer :: nn
       logical :: can_have_sub
       select type (core)
       class is (prc_user_defined_base_t)
          can_have_sub = nlo_t == NLO_VIRTUAL .or. &
               (nlo_t == NLO_REAL .and. term%i_term_global == term%i_sub) .or. &
               nlo_t == NLO_MISMATCH .or. nlo_t == NLO_DGLAP
          if (can_have_sub) then
             nn = (n_sub + 1) * n
          else
             nn = n
          end if
       class default
          nn = n
       end select
       allocate (term%flv (nn), term%col (nn), term%hel (nn))
       allocate (flv (n_tot), col (n_tot), hel (n_tot))
       allocate (qn (n_tot))
     end subroutine fill_quantum_numbers
 
     subroutine setup_states_openloops ()
       integer :: s, f, c, h, i
       i = 0
       associate (data => term%data)
          do s = 0, n_sub
              do f = 1, data%n_flv
                 do h = 1, data%n_hel
                    do c = 1, data%n_col
                       i = i + 1
                       term%flv(i) = f
                       term%hel(i) = h
                       !!! Dummy-initialization of color
                       term%col(i) = c
                       call flv%init (data%flv_state (:,f), model)
                       call color_init_from_array (col, &
                            data%col_state(:,:,c), data%ghost_flag(:,c))
                       call col(1:data%n_in)%invert ()
                       if (is_pol) then
                          call hel%init (data%hel_state (:,h))
                          call qn%init (flv, hel, col, s)
                       else
                          call qn%init (flv, col, s)
                       end if
                       call qn%tag_hard_process ()
                       call term%int%add_state (qn)
                   end do
                end do
              end do
          end do
       end associate
     end subroutine setup_states_openloops
 
     subroutine setup_states_threshold ()
       integer :: s, f, c, h, i
       i = 0
       n_sub = 0; if (nlo_t == NLO_VIRTUAL) n_sub = 1
       associate (data => term%data)
          do s = 0, n_sub
             do f = 1, term%data%n_flv
                do h = 1, data%n_hel
                   do c = 1, data%n_col
                      i = i + 1
                      term%flv(i) = f
                      term%hel(i) = h
                      !!! Dummy-initialization of color
                      term%col(i) = 1
                      call flv%init (term%data%flv_state (:,f), model)
                      if (is_pol) then
                         call hel%init (data%hel_state (:,h))
                         call qn%init (flv, hel, s)
                      else
                         call qn%init (flv, s)
                      end if
                      call qn%tag_hard_process ()
                      call term%int%add_state (qn)
                   end do
                end do
             end do
          end do
       end associate
     end subroutine setup_states_threshold
 
     subroutine setup_states_other_user_defined ()
       integer :: s, f, i
       integer :: n_sub
       if (is_pol) &
          call msg_fatal ("Polarized beams only supported by OpenLoops")
       i = 0
       n_sub = 0; if (nlo_t == NLO_VIRTUAL) n_sub = 1
       do s = 0, n_sub
          do f = 1, term%data%n_flv
             i = i + 1
             term%flv(i) = f
             term%hel(i) = 1
             term%col(i) = 1
             call flv%init (term%data%flv_state (:,f), model)
             call qn%init (flv, s)
             call qn%tag_hard_process ()
             call term%int%add_state (qn)
          end do
       end do
     end subroutine setup_states_other_user_defined
 
     subroutine setup_states_omega ()
       integer :: f, h, c, i
       i = 0
       associate (data => term%data)
          do f = 1, data%n_flv
             do h = 1, data%n_hel
               do c = 1, data%n_col
                  if (core%is_allowed (term%i_term, f, h, c)) then
                     i = i + 1
                     term%flv(i) = f
                     term%hel(i) = h
                     term%col(i) = c
                     call flv%init (data%flv_state(:,f), model)
                     call color_init_from_array (col, &
                          data%col_state(:,:,c), &
                          data%ghost_flag(:,c))
                     call col(:data%n_in)%invert ()
                     call hel%init (data%hel_state(:,h))
                     call qn%init (flv, col, hel)
                     call qn%tag_hard_process ()
                     call term%int%add_state (qn)
                  end if
               end do
             end do
          end do
       end associate
     end subroutine setup_states_omega
 
   end subroutine process_term_setup_interaction
 
 @ %def process_term_setup_interaction
 @
 <<Process config: process term: TBP>>=
   procedure :: get_process_constants => process_term_get_process_constants
 <<Process config: procedures>>=
    subroutine process_term_get_process_constants &
        (term, prc_constants)
     class(process_term_t), intent(inout) :: term
     type(process_constants_t), intent(out) :: prc_constants
     prc_constants = term%data
   end subroutine process_term_get_process_constants
 
 @ %def process_term_get_process_constants
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Process call statistics}
 Very simple object for statistics.  Could be moved to a more basic chapter.
 <<[[process_counter.f90]]>>=
 <<File header>>
 
 module process_counter
 
   use io_units
 
 <<Standard module head>>
 
 <<Process counter: public>>
 
 <<Process counter: parameters>>
 
 <<Process counter: types>>
 
 contains
 
 <<Process counter: procedures>>
 
 end module process_counter
 @ %def process_counter
 @ This object can record process calls, categorized by evaluation
 status.  It is a part of the [[mci_entry]] component below.
 <<Process counter: public>>=
   public :: process_counter_t
 <<Process counter: types>>=
   type :: process_counter_t
      integer :: total = 0
      integer :: failed_kinematics = 0
      integer :: failed_cuts = 0
      integer :: has_passed = 0
      integer :: evaluated = 0
      integer :: complete = 0
    contains
    <<Process counter: process counter: TBP>>
   end type process_counter_t
 
 @ %def process_counter_t
 @ Here are the corresponding numeric codes:
 <<Process counter: parameters>>=
   integer, parameter, public :: STAT_UNDEFINED = 0
   integer, parameter, public :: STAT_INITIAL = 1
   integer, parameter, public :: STAT_ACTIVATED = 2
   integer, parameter, public :: STAT_BEAM_MOMENTA = 3
   integer, parameter, public :: STAT_FAILED_KINEMATICS = 4
   integer, parameter, public :: STAT_SEED_KINEMATICS = 5
   integer, parameter, public :: STAT_HARD_KINEMATICS = 6
   integer, parameter, public :: STAT_EFF_KINEMATICS = 7
   integer, parameter, public :: STAT_FAILED_CUTS = 8
   integer, parameter, public :: STAT_PASSED_CUTS = 9
   integer, parameter, public :: STAT_EVALUATED_TRACE = 10
   integer, parameter, public :: STAT_EVENT_COMPLETE = 11
 
 @ %def STAT_UNDEFINED STAT_INITIAL STAT_ACTIVATED
 @ %def STAT_BEAM_MOMENTA STAT_FAILED_KINEMATICS
 @ %def STAT_SEED_KINEMATICS STAT_HARD_KINEMATICS STAT_EFF_KINEMATICS
 @ %def STAT_EVALUATED_TRACE STAT_EVENT_COMPLETE
 @ Output.
 <<Process counter: process counter: TBP>>=
   procedure :: write => process_counter_write
 <<Process counter: procedures>>=
   subroutine process_counter_write (object, unit)
     class(process_counter_t), intent(in) :: object
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     if (object%total > 0) then
        write (u, "(1x,A)")  "Call statistics (current run):"
        write (u, "(3x,A,I0)")  "total       = ", object%total
        write (u, "(3x,A,I0)")  "failed kin. = ", object%failed_kinematics
        write (u, "(3x,A,I0)")  "failed cuts = ", object%failed_cuts
        write (u, "(3x,A,I0)")  "passed cuts = ", object%has_passed
        write (u, "(3x,A,I0)")  "evaluated   = ", object%evaluated
     else
        write (u, "(1x,A)")  "Call statistics (current run): [no calls]"
     end if
   end subroutine process_counter_write
 
 @ %def process_counter_write
 @ Reset.  Just enforce default initialization.
 <<Process counter: process counter: TBP>>=
   procedure :: reset => process_counter_reset
 <<Process counter: procedures>>=
   subroutine process_counter_reset (counter)
     class(process_counter_t), intent(out) :: counter
     counter%total = 0
     counter%failed_kinematics = 0
     counter%failed_cuts = 0
     counter%has_passed = 0
     counter%evaluated = 0
     counter%complete = 0
   end subroutine process_counter_reset
 
 @ %def process_counter_reset
 @ We record an event according to the lowest status code greater or
 equal to the actual status.  This is actually done by the process
 instance; the process object just copies the instance counter.
 <<Process counter: process counter: TBP>>=
   procedure :: record => process_counter_record
 <<Process counter: procedures>>=
   subroutine process_counter_record (counter, status)
     class(process_counter_t), intent(inout) :: counter
     integer, intent(in) :: status
     if (status <= STAT_FAILED_KINEMATICS) then
        counter%failed_kinematics = counter%failed_kinematics + 1
     else if (status <= STAT_FAILED_CUTS) then
        counter%failed_cuts = counter%failed_cuts + 1
     else if (status <= STAT_PASSED_CUTS) then
        counter%has_passed = counter%has_passed + 1
     else
        counter%evaluated = counter%evaluated + 1
     end if
     counter%total = counter%total + 1
   end subroutine process_counter_record
 
 @ %def process_counter_record
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Multi-channel integration}
 <<[[process_mci.f90]]>>=
 <<File header>>
 
 module process_mci
 
 <<Use kinds>>
 <<Use strings>>
   use io_units
   use diagnostics
   use physics_defs
   use md5
   use cputime
   use rng_base
   use mci_base
   use variables
   use integration_results
   use process_libraries
   use phs_base
   use process_counter
   use process_config
 
 
 <<Standard module head>>
 
 <<Process mci: public>>
 
 <<Process mci: parameters>>
 
 <<Process mci: types>>
 
 contains
 
 <<Process mci: procedures>>
 
 end module process_mci
 @ %def process_mci
 \subsection{Process MCI entry}
 The [[process_mci_entry_t]] block contains, for each process component that is
 integrated independently, the configuration data for its MC input parameters.
 Each input parameter set is handled by a [[mci_t]] integrator.
 
 The MC input parameter set is broken down into the parameters required by the
 structure-function chain and the parameters required by the phase space of the
 elementary process.
 
 The MD5 sum collects all information about the associated processes
 that may affect the integration.  It does not contain the MCI object
 itself or integration results.
 
 MC integration is organized in passes.  Each pass may consist of
 several iterations, and for each iteration there is a number of
 calls.  We store explicitly the values that apply to the current
 pass.  Previous values are archived in the [[results]] object.
 
 The [[counter]] receives the counter statistics from the associated
 process instance, for diagnostics.
 
 The [[results]] object records results, broken down in passes and iterations.
 <<Process mci: public>>=
   public :: process_mci_entry_t
 <<Process mci: types>>=
   type :: process_mci_entry_t
      integer :: i_mci = 0
      integer, dimension(:), allocatable :: i_component
      integer :: process_type = PRC_UNKNOWN
      integer :: n_par = 0
      integer :: n_par_sf = 0
      integer :: n_par_phs = 0
      character(32) :: md5sum = ""
      integer :: pass = 0
      integer :: n_it = 0
      integer :: n_calls = 0
      logical :: activate_timer = .false.
      real(default) :: error_threshold = 0
      class(mci_t), allocatable :: mci
      type(process_counter_t) :: counter
      type(integration_results_t) :: results
      logical :: negative_weights
      logical :: combined_integration = .false.
      integer :: real_partition_type = REAL_FULL
      integer :: associated_real_component = 0
    contains
    <<Process mci: process mci entry: TBP>>
   end type process_mci_entry_t
 
 @ %def process_mci_entry_t
 @ Finalizer for the [[mci]] component.
 <<Process mci: process mci entry: TBP>>=
   procedure :: final => process_mci_entry_final
 <<Process mci: procedures>>=
   subroutine process_mci_entry_final (object)
     class(process_mci_entry_t), intent(inout) :: object
     if (allocated (object%mci))  call object%mci%final ()
   end subroutine process_mci_entry_final
 
 @ %def process_mci_entry_final
 @ Output.  Write pass/iteration information only if set (the pass
 index is nonzero).  Write the MCI block only if it exists (for some
 self-tests it does not).  Write results only if there are any.
 <<Process mci: process mci entry: TBP>>=
   procedure :: write => process_mci_entry_write
 <<Process mci: procedures>>=
   subroutine process_mci_entry_write (object, unit, pacify)
     class(process_mci_entry_t), intent(in) :: object
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: pacify
     integer :: u
     u = given_output_unit (unit)
     write (u, "(3x,A,I0)")  "Associated components = ", object%i_component
     write (u, "(3x,A,I0)")  "MC input parameters   = ", object%n_par
     write (u, "(3x,A,I0)")  "MC parameters (SF)    = ", object%n_par_sf
     write (u, "(3x,A,I0)")  "MC parameters (PHS)   = ", object%n_par_phs
     if (object%pass > 0) then
        write (u, "(3x,A,I0)")  "Current pass          = ", object%pass
        write (u, "(3x,A,I0)")  "Number of iterations  = ", object%n_it
        write (u, "(3x,A,I0)")  "Number of calls       = ", object%n_calls
     end if
     if (object%md5sum /= "") then
        write (u, "(3x,A,A,A)") "MD5 sum (components)  = '", object%md5sum, "'"
     end if
     if (allocated (object%mci)) then
        call object%mci%write (u)
     end if
     call object%counter%write (u)
     if (object%results%exist ()) then
        call object%results%write (u, suppress = pacify)
        call object%results%write_chain_weights (u)
     end if
   end subroutine process_mci_entry_write
 
 @ %def process_mci_entry_write
 @ Initialize.  From the existing configuration, we obtain the number of
 channels and the number of parameters, separately for the structure-function
 chain and for the associated process component.  We assume that the
 phase-space object has already been configured.
 
 The allocation of the MCI integrator with the appropriate concrete type is the
 duty of the process core.
 
 We assume that there is only one component associated with a MCI entry.  This
 restriction should be relaxed.
 <<Process mci: process mci entry: TBP>>=
   procedure :: init => process_mci_entry_init
 <<Process mci: procedures>>=
   subroutine process_mci_entry_init (mci_entry, &
        process_type, i_mci, i_component, component, &
        n_sfpar, rng_factory)
     class(process_mci_entry_t), intent(inout) :: mci_entry
     integer, intent(in) :: process_type
     integer, intent(in) :: i_mci
     integer, intent(in) :: i_component
     type(process_component_t), intent(in), target :: component
     integer, intent(in) :: n_sfpar
     class(rng_factory_t), intent(inout) :: rng_factory
     class(rng_t), allocatable :: rng
     associate (phs_config => component%phs_config)
       mci_entry%i_mci = i_mci
       call mci_entry%create_component_list (i_component, component%get_config ())
       mci_entry%n_par_sf = n_sfpar
       mci_entry%n_par_phs = phs_config%get_n_par ()
       mci_entry%n_par = mci_entry%n_par_sf + mci_entry%n_par_phs
       mci_entry%process_type = process_type
       if (component%has_mci_template ()) then
          allocate (mci_entry%mci, source=component%extract_mci_template ())
          call mci_entry%mci%record_index (mci_entry%i_mci)
          call mci_entry%mci%set_dimensions &
               (mci_entry%n_par, phs_config%get_n_channel ())
          call mci_entry%mci%declare_flat_dimensions &
               (phs_config%get_flat_dimensions ())
          if (phs_config%provides_equivalences) then
             call mci_entry%mci%declare_equivalences &
                  (phs_config%channel, mci_entry%n_par_sf)
          end if
          if (phs_config%provides_chains) then
             call mci_entry%mci%declare_chains (phs_config%chain)
          end if
          call rng_factory%make (rng)
          call mci_entry%mci%import_rng (rng)
       end if
       call mci_entry%results%init (process_type)
     end associate
   end subroutine process_mci_entry_init
 
 @ %def process_mci_entry_init
 @
 <<Process mci: parameters>>=
   integer, parameter, public :: REAL_FULL = 0
   integer, parameter, public :: REAL_SINGULAR = 1
   integer, parameter, public :: REAL_FINITE = 2
 @
 <<Process mci: process mci entry: TBP>>=
   procedure :: create_component_list => &
      process_mci_entry_create_component_list
 <<Process mci: procedures>>=
   subroutine process_mci_entry_create_component_list (mci_entry, &
      i_component, component_config)
     class (process_mci_entry_t), intent(inout) :: mci_entry
     integer, intent(in) :: i_component
     type(process_component_def_t), intent(in) :: component_config
     integer, dimension(:), allocatable :: i_list
     integer :: n
     integer, save :: i_rfin_offset = 0
     call msg_debug (D_PROCESS_INTEGRATION, "process_mci_entry_create_component_list")
     if (mci_entry%combined_integration) then
        n = get_n_components (mci_entry%real_partition_type)
        allocate (i_list (n))
        call msg_debug (D_PROCESS_INTEGRATION, &
             "mci_entry%real_partition_type", mci_entry%real_partition_type)
        select case (mci_entry%real_partition_type)
        case (REAL_FULL)
           i_list = component_config%get_association_list ()
           allocate (mci_entry%i_component (size (i_list)))
           mci_entry%i_component = i_list
        case (REAL_SINGULAR)
           i_list = component_config%get_association_list (ASSOCIATED_REAL_FIN)
           allocate (mci_entry%i_component (size(i_list)))
           mci_entry%i_component = i_list
        case (REAL_FINITE)
           allocate (mci_entry%i_component (1))
           mci_entry%i_component(1) = &
                component_config%get_associated_real_fin () + i_rfin_offset
           i_rfin_offset = i_rfin_offset + 1
        end select
     else
        allocate (mci_entry%i_component (1))
        mci_entry%i_component(1) = i_component
     end if
   contains
     function get_n_components (damping_type) result (n_components)
       integer :: n_components
       integer, intent(in) :: damping_type
       select case (damping_type)
       case (REAL_FULL)
          n_components = size (component_config%get_association_list ())
       case (REAL_SINGULAR)
          n_components = size (component_config%get_association_list &
             (ASSOCIATED_REAL_FIN))
       end select
       call msg_debug (D_PROCESS_INTEGRATION, "n_components", n_components)
     end function get_n_components
   end subroutine process_mci_entry_create_component_list
 
 @ %def process_mci_entry_create_component_list
 @
 <<Process mci: process mci entry: TBP>>=
   procedure :: set_combined_integration => &
        process_mci_entry_set_combined_integration
 <<Process mci: procedures>>=
   subroutine process_mci_entry_set_combined_integration (mci_entry, value)
     class(process_mci_entry_t), intent(inout) :: mci_entry
     logical, intent(in), optional :: value
     if (present (value)) &
        mci_entry%combined_integration = value
   end subroutine process_mci_entry_set_combined_integration
 
 @ %def process_mci_entry_set_combined_integration
 @
 <<Process mci: process mci entry: TBP>>=
   procedure :: set_associated_real_component &
       => process_mci_entry_set_associated_real_component
 <<Process mci: procedures>>=
   subroutine process_mci_entry_set_associated_real_component (mci_entry, i)
      class(process_mci_entry_t), intent(inout) :: mci_entry
      integer, intent(in) :: i
      mci_entry%associated_real_component = i
   end subroutine process_mci_entry_set_associated_real_component
 
 @ %def process_mci_entry_set_associated_real_component
 @ Set some additional parameters.
 <<Process mci: process mci entry: TBP>>=
   procedure :: set_parameters => process_mci_entry_set_parameters
 <<Process mci: procedures>>=
   subroutine process_mci_entry_set_parameters (mci_entry, var_list)
     class(process_mci_entry_t), intent(inout) :: mci_entry
     type(var_list_t), intent(in) :: var_list
     integer :: integration_results_verbosity
     real(default) :: error_threshold
     integration_results_verbosity = &
          var_list%get_ival (var_str ("integration_results_verbosity"))
     error_threshold = &
          var_list%get_rval (var_str ("error_threshold"))
     mci_entry%activate_timer = &
          var_list%get_lval (var_str ("?integration_timer"))
     call mci_entry%results%set_verbosity (integration_results_verbosity)
     call mci_entry%results%set_error_threshold (error_threshold)
   end subroutine process_mci_entry_set_parameters
 
 @ %def process_mci_entry_set_parameters
 @ Compute an MD5 sum that summarizes all information that could
 influence integration results, for the associated process components.
 We take the process-configuration MD5 sum which represents parameters,
 cuts, etc., the MD5 sums for the process component definitions and
 their phase space objects (which should be configured), and the beam
 configuration MD5 sum.  (The QCD setup is included in the process
 configuration data MD5 sum.)
 
 Done only once, when the MD5 sum is still empty.
 <<Process mci: process mci entry: TBP>>=
   procedure :: compute_md5sum => process_mci_entry_compute_md5sum
 <<Process mci: procedures>>=
   subroutine process_mci_entry_compute_md5sum (mci_entry, &
        config, component, beam_config)
     class(process_mci_entry_t), intent(inout) :: mci_entry
     type(process_config_data_t), intent(in) :: config
     type(process_component_t), dimension(:), intent(in) :: component
     type(process_beam_config_t), intent(in) :: beam_config
     type(string_t) :: buffer
     integer :: i
     if (mci_entry%md5sum == "") then
        buffer = config%get_md5sum () // beam_config%get_md5sum ()
        do i = 1, size (component)
           if (component(i)%is_active ()) then
              buffer = buffer // component(i)%get_md5sum ()
           end if
        end do
        mci_entry%md5sum = md5sum (char (buffer))
     end if
     if (allocated (mci_entry%mci)) then
        call mci_entry%mci%set_md5sum (mci_entry%md5sum)
     end if
   end subroutine process_mci_entry_compute_md5sum
 
 @ %def process_mci_entry_compute_md5sum
 @ Test the MCI sampler by calling it a given number of time, discarding the
 results.  The instance should be initialized.
 
 The [[mci_entry]] is [[intent(inout)]] because the integrator contains
 the random-number state.
 <<Process mci: process mci entry: TBP>>=
   procedure :: sampler_test => process_mci_entry_sampler_test
 <<Process mci: procedures>>=
   subroutine process_mci_entry_sampler_test (mci_entry, mci_sampler, n_calls)
     class(process_mci_entry_t), intent(inout) :: mci_entry
     class(mci_sampler_t), intent(inout), target :: mci_sampler
     integer, intent(in) :: n_calls
     call mci_entry%mci%sampler_test (mci_sampler, n_calls)
   end subroutine process_mci_entry_sampler_test
 
 @ %def process_mci_entry_sampler_test
 @ Integrate.
 
 The [[integrate]] method counts as an integration pass; the pass count is
 increased by one.  We transfer the pass parameters (number of iterations and
 number of calls) to the actual integration routine.
 
 The [[mci_entry]] is [[intent(inout)]] because the integrator contains
 the random-number state.
 
 Note: The results are written to screen and to logfile.  This behavior
 is hardcoded.
 <<Process mci: process mci entry: TBP>>=
   procedure :: integrate => process_mci_entry_integrate
   procedure :: final_integration => process_mci_entry_final_integration
 <<Process mci: procedures>>=
   subroutine process_mci_entry_integrate (mci_entry, mci_instance, &
          mci_sampler, n_it, n_calls, &
        adapt_grids, adapt_weights, final, pacify, &
        nlo_type)
     class(process_mci_entry_t), intent(inout) :: mci_entry
     class(mci_instance_t), intent(inout) :: mci_instance
     class(mci_sampler_t), intent(inout) :: mci_sampler
     integer, intent(in) :: n_it
     integer, intent(in) :: n_calls
     logical, intent(in), optional :: adapt_grids
     logical, intent(in), optional :: adapt_weights
     logical, intent(in), optional :: final, pacify
     integer, intent(in), optional :: nlo_type
     integer :: u_log
     u_log = logfile_unit ()
     mci_entry%pass = mci_entry%pass + 1
     mci_entry%n_it = n_it
     mci_entry%n_calls = n_calls
     if (mci_entry%pass == 1)  &
          call mci_entry%mci%startup_message (n_calls = n_calls)
     call mci_entry%mci%set_timer (active = mci_entry%activate_timer)
     call mci_entry%results%display_init (screen = .true., unit = u_log)
     call mci_entry%results%new_pass ()
     if (present (nlo_type)) then
        select case (nlo_type)
        case (NLO_VIRTUAL, NLO_REAL, NLO_MISMATCH, NLO_DGLAP)
           mci_instance%negative_weights = .true.
        end select
     end if
     call mci_entry%mci%add_pass (adapt_grids, adapt_weights, final)
     call mci_entry%mci%start_timer ()
     call mci_entry%mci%integrate (mci_instance, mci_sampler, n_it, &
          n_calls, mci_entry%results, pacify = pacify)
     call mci_entry%mci%stop_timer ()
     if (signal_is_pending ())  return
   end subroutine process_mci_entry_integrate
 
   subroutine process_mci_entry_final_integration (mci_entry)
     class(process_mci_entry_t), intent(inout) :: mci_entry
     call mci_entry%results%display_final ()
     call mci_entry%time_message ()
   end subroutine process_mci_entry_final_integration
 
 @ %def process_mci_entry_integrate
 @ %def process_mci_entry_final_integration
 @ If appropriate, issue an informative message about the expected time
 for an event sample.
 <<Process mci: process mci entry: TBP>>=
   procedure :: get_time => process_mci_entry_get_time
   procedure :: time_message => process_mci_entry_time_message
 <<Process mci: procedures>>=
   subroutine process_mci_entry_get_time (mci_entry, time, sample)
     class(process_mci_entry_t), intent(in) :: mci_entry
     type(time_t), intent(out) :: time
     integer, intent(in) :: sample
     real(default) :: time_last_pass, efficiency, calls
     time_last_pass = mci_entry%mci%get_time ()
     calls = mci_entry%results%get_n_calls ()
     efficiency = mci_entry%mci%get_efficiency ()
     if (time_last_pass > 0 .and. calls > 0 .and. efficiency > 0) then
        time = nint (time_last_pass / calls / efficiency * sample)
     end if
   end subroutine process_mci_entry_get_time
 
   subroutine process_mci_entry_time_message (mci_entry)
     class(process_mci_entry_t), intent(in) :: mci_entry
     type(time_t) :: time
     integer :: sample
     sample = 10000
     call mci_entry%get_time (time, sample)
     if (time%is_known ()) then
        call msg_message ("Time estimate for generating 10000 events: " &
             // char (time%to_string_dhms ()))
     end if
   end subroutine process_mci_entry_time_message
 
 @ %def process_mci_entry_time_message
 @ Prepare event generation.  (For the test integrator, this does nothing.  It
 is relevant for the VAMP integrator.)
 <<Process mci: process mci entry: TBP>>=
   procedure :: prepare_simulation => process_mci_entry_prepare_simulation
 <<Process mci: procedures>>=
   subroutine process_mci_entry_prepare_simulation (mci_entry)
     class(process_mci_entry_t), intent(inout) :: mci_entry
     call mci_entry%mci%prepare_simulation ()
   end subroutine process_mci_entry_prepare_simulation
 
 @ %def process_mci_entry_prepare_simulation
 @ Generate an event.  The instance should be initialized,
 otherwise event generation is directed by the [[mci]] integrator
 subobject.  The integrator instance is contained in a [[mci_work]]
 subobject of the process instance, which simultaneously serves as the
 sampler object.  (We avoid the anti-aliasing rules if we assume that
 the sampling itself does not involve the integrator instance contained in the
 process instance.)
 
 Regarding weighted events, we only take events which are valid, which
 means that they have valid kinematics and have passed cuts.
 Therefore, we have a rejection loop.  For unweighted events, the
 unweighting routine should already take care of this.
 <<Process mci: process mci entry: TBP>>=
   procedure :: generate_weighted_event => &
        process_mci_entry_generate_weighted_event
   procedure :: generate_unweighted_event => &
        process_mci_entry_generate_unweighted_event
 <<Process mci: procedures>>=
   subroutine process_mci_entry_generate_weighted_event (mci_entry, &
       mci_instance, mci_sampler, keep_failed)
     class(process_mci_entry_t), intent(inout) :: mci_entry
     class(mci_instance_t), intent(inout) :: mci_instance
     class(mci_sampler_t), intent(inout) :: mci_sampler
     logical, intent(in) :: keep_failed
     logical :: generate_new
     generate_new = .true.
     REJECTION: do while (generate_new)
        call mci_entry%mci%generate_weighted_event (mci_instance, mci_sampler)
        if (signal_is_pending ())  return
        if (.not. mci_sampler%is_valid()) then
           if (keep_failed) then
              generate_new = .false.
           else
              generate_new = .true.
           end if
        else
           generate_new = .false.
        end if
     end do REJECTION
   end subroutine process_mci_entry_generate_weighted_event
 
   subroutine process_mci_entry_generate_unweighted_event (mci_entry, mci_instance, mci_sampler)
     class(process_mci_entry_t), intent(inout) :: mci_entry
     class(mci_instance_t), intent(inout) :: mci_instance
     class(mci_sampler_t), intent(inout) :: mci_sampler
     call mci_entry%mci%generate_unweighted_event (mci_instance, mci_sampler)
   end subroutine process_mci_entry_generate_unweighted_event
 
 @ %def process_mci_entry_generate_weighted_event
 @ %def process_mci_entry_generate_unweighted_event
 @ Extract results.
 <<Process mci: process mci entry: TBP>>=
   procedure :: has_integral => process_mci_entry_has_integral
   procedure :: get_integral => process_mci_entry_get_integral
   procedure :: get_error => process_mci_entry_get_error
   procedure :: get_accuracy => process_mci_entry_get_accuracy
   procedure :: get_chi2 => process_mci_entry_get_chi2
   procedure :: get_efficiency => process_mci_entry_get_efficiency
 <<Process mci: procedures>>=
   function process_mci_entry_has_integral (mci_entry) result (flag)
     class(process_mci_entry_t), intent(in) :: mci_entry
     logical :: flag
     flag = mci_entry%results%exist ()
   end function process_mci_entry_has_integral
 
   function process_mci_entry_get_integral (mci_entry) result (integral)
     class(process_mci_entry_t), intent(in) :: mci_entry
     real(default) :: integral
     integral = mci_entry%results%get_integral ()
   end function process_mci_entry_get_integral
 
   function process_mci_entry_get_error (mci_entry) result (error)
     class(process_mci_entry_t), intent(in) :: mci_entry
     real(default) :: error
     error = mci_entry%results%get_error ()
   end function process_mci_entry_get_error
 
   function process_mci_entry_get_accuracy (mci_entry) result (accuracy)
     class(process_mci_entry_t), intent(in) :: mci_entry
     real(default) :: accuracy
     accuracy = mci_entry%results%get_accuracy ()
   end function process_mci_entry_get_accuracy
 
   function process_mci_entry_get_chi2 (mci_entry) result (chi2)
     class(process_mci_entry_t), intent(in) :: mci_entry
     real(default) :: chi2
     chi2 = mci_entry%results%get_chi2 ()
   end function process_mci_entry_get_chi2
 
   function process_mci_entry_get_efficiency (mci_entry) result (efficiency)
     class(process_mci_entry_t), intent(in) :: mci_entry
     real(default) :: efficiency
     efficiency = mci_entry%results%get_efficiency ()
   end function process_mci_entry_get_efficiency
 
 @ %def process_mci_entry_get_integral process_mci_entry_get_error
 @ %def process_mci_entry_get_accuracy process_mci_entry_get_chi2
 @ %def process_mci_entry_get_efficiency
 @ Return the MCI checksum.  This may be the one used for
 configuration, but may also incorporate results, if they change the
 state of the integrator (adaptation).
 <<Process mci: process mci entry: TBP>>=
   procedure :: get_md5sum => process_mci_entry_get_md5sum
 <<Process mci: procedures>>=
   pure function process_mci_entry_get_md5sum (entry) result (md5sum)
     class(process_mci_entry_t), intent(in) :: entry
     character(32) :: md5sum
     md5sum = entry%mci%get_md5sum ()
   end function process_mci_entry_get_md5sum
 
 @ %def process_mci_entry_get_md5sum
 @
 \subsection{MC parameter set and MCI instance}
 For each process component that is associated with a multi-channel integration
 (MCI) object, the [[mci_work_t]] object contains the currently active
 parameter set.  It also holds the implementation of the [[mci_instance_t]]
 that the integrator needs for doing its work.
 <<Process mci: public>>=
   public :: mci_work_t
 <<Process mci: types>>=
   type :: mci_work_t
      type(process_mci_entry_t), pointer :: config => null ()
      real(default), dimension(:), allocatable :: x
      class(mci_instance_t), pointer :: mci => null ()
      type(process_counter_t) :: counter
      logical :: keep_failed_events = .false.
    contains
    <<Process mci: mci work: TBP>>
   end type mci_work_t
 
 @ %def mci_work_t
 @ First write configuration data, then the current values.
 <<Process mci: mci work: TBP>>=
   procedure :: write => mci_work_write
 <<Process mci: procedures>>=
   subroutine mci_work_write (mci_work, unit, testflag)
     class(mci_work_t), intent(in) :: mci_work
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: testflag
     integer :: u, i
     u = given_output_unit (unit)
     write (u, "(1x,A,I0,A)")  "Active MCI instance #", &
          mci_work%config%i_mci, " ="
     write (u, "(2x)", advance="no")
     do i = 1, mci_work%config%n_par
        write (u, "(1x,F7.5)", advance="no")  mci_work%x(i)
        if (i == mci_work%config%n_par_sf) &
             write (u, "(1x,'|')", advance="no")
     end do
     write (u, *)
     if (associated (mci_work%mci)) then
        call mci_work%mci%write (u, pacify = testflag)
        call mci_work%counter%write (u)
     end if
   end subroutine mci_work_write
 
 @ %def mci_work_write
 @ The [[mci]] component may require finalization.
 <<Process mci: mci work: TBP>>=
   procedure :: final => mci_work_final
 <<Process mci: procedures>>=
   subroutine mci_work_final (mci_work)
     class(mci_work_t), intent(inout) :: mci_work
     if (associated (mci_work%mci)) then
        call mci_work%mci%final ()
        deallocate (mci_work%mci)
     end if
   end subroutine mci_work_final
 
 @ %def mci_work_final
 @ Initialize with the maximum length that we will need.  Contents are
 not initialized.
 
 The integrator inside the [[mci_entry]] object is responsible for
 allocating and initializing its own instance, which is referred to by
 a pointer in the [[mci_work]] object.
 <<Process mci: mci work: TBP>>=
   procedure :: init => mci_work_init
 <<Process mci: procedures>>=
   subroutine mci_work_init (mci_work, mci_entry)
     class(mci_work_t), intent(out) :: mci_work
     type(process_mci_entry_t), intent(in), target :: mci_entry
     mci_work%config => mci_entry
     allocate (mci_work%x (mci_entry%n_par))
     if (allocated (mci_entry%mci)) then
        call mci_entry%mci%allocate_instance (mci_work%mci)
        call mci_work%mci%init (mci_entry%mci)
     end if
   end subroutine mci_work_init
 
 @ %def mci_work_init
 @ Set parameters explicitly, either all at once, or separately for the
 structure-function and process parts.
 <<Process mci: mci work: TBP>>=
   procedure :: set => mci_work_set
   procedure :: set_x_strfun => mci_work_set_x_strfun
   procedure :: set_x_process => mci_work_set_x_process
 <<Process mci: procedures>>=
   subroutine mci_work_set (mci_work, x)
     class(mci_work_t), intent(inout) :: mci_work
     real(default), dimension(:), intent(in) :: x
     mci_work%x = x
   end subroutine mci_work_set
 
   subroutine mci_work_set_x_strfun (mci_work, x)
     class(mci_work_t), intent(inout) :: mci_work
     real(default), dimension(:), intent(in) :: x
     mci_work%x(1 : mci_work%config%n_par_sf) = x
   end subroutine mci_work_set_x_strfun
 
   subroutine mci_work_set_x_process (mci_work, x)
     class(mci_work_t), intent(inout) :: mci_work
     real(default), dimension(:), intent(in) :: x
     mci_work%x(mci_work%config%n_par_sf + 1 : mci_work%config%n_par) = x
   end subroutine mci_work_set_x_process
 
 @ %def mci_work_set
 @ %def mci_work_set_x_strfun
 @ %def mci_work_set_x_process
 @ Return the array of active components, i.e., those that correspond
 to the currently selected MC parameter set.
 <<Process mci: mci work: TBP>>=
   procedure :: get_active_components => mci_work_get_active_components
 <<Process mci: procedures>>=
   function mci_work_get_active_components (mci_work) result (i_component)
     class(mci_work_t), intent(in) :: mci_work
     integer, dimension(:), allocatable :: i_component
     allocate (i_component (size (mci_work%config%i_component)))
     i_component = mci_work%config%i_component
   end function mci_work_get_active_components
 
 @ %def mci_work_get_active_components
 @ Return the active parameters as a simple array with correct length.
 Do this separately for the structure-function parameters and the
 process parameters.
 <<Process mci: mci work: TBP>>=
   procedure :: get_x_strfun => mci_work_get_x_strfun
   procedure :: get_x_process => mci_work_get_x_process
 <<Process mci: procedures>>=
   pure function mci_work_get_x_strfun (mci_work) result (x)
     class(mci_work_t), intent(in) :: mci_work
     real(default), dimension(mci_work%config%n_par_sf) :: x
     x = mci_work%x(1 : mci_work%config%n_par_sf)
   end function mci_work_get_x_strfun
 
   pure function mci_work_get_x_process (mci_work) result (x)
     class(mci_work_t), intent(in) :: mci_work
     real(default), dimension(mci_work%config%n_par_phs) :: x
     x = mci_work%x(mci_work%config%n_par_sf + 1 : mci_work%config%n_par)
   end function mci_work_get_x_process
 
 @ %def mci_work_get_x_strfun
 @ %def mci_work_get_x_process
 @ Initialize and finalize event generation for the specified MCI
 entry.  This also resets the counter.
 <<Process mci: mci work: TBP>>=
   procedure :: init_simulation => mci_work_init_simulation
   procedure :: final_simulation => mci_work_final_simulation
 <<Process mci: procedures>>=
   subroutine mci_work_init_simulation (mci_work, safety_factor, keep_failed_events)
     class(mci_work_t), intent(inout) :: mci_work
     real(default), intent(in), optional :: safety_factor
     logical, intent(in), optional :: keep_failed_events
     call mci_work%mci%init_simulation (safety_factor)
     call mci_work%counter%reset ()
     if (present (keep_failed_events)) &
        mci_work%keep_failed_events = keep_failed_events
   end subroutine mci_work_init_simulation
 
   subroutine mci_work_final_simulation (mci_work)
     class(mci_work_t), intent(inout) :: mci_work
     call mci_work%mci%final_simulation ()
   end subroutine mci_work_final_simulation
 
 @ %def mci_work_init_simulation
 @ %def mci_work_final_simulation
 @ Counter.
 <<Process mci: mci work: TBP>>=
   procedure :: reset_counter => mci_work_reset_counter
   procedure :: record_call => mci_work_record_call
   procedure :: get_counter => mci_work_get_counter
 <<Process mci: procedures>>=
   subroutine mci_work_reset_counter (mci_work)
     class(mci_work_t), intent(inout) :: mci_work
     call mci_work%counter%reset ()
   end subroutine mci_work_reset_counter
 
   subroutine mci_work_record_call (mci_work, status)
     class(mci_work_t), intent(inout) :: mci_work
     integer, intent(in) :: status
     call mci_work%counter%record (status)
   end subroutine mci_work_record_call
 
   pure function mci_work_get_counter (mci_work) result (counter)
     class(mci_work_t), intent(in) :: mci_work
     type(process_counter_t) :: counter
     counter = mci_work%counter
   end function mci_work_get_counter
 
 @ %def mci_work_reset_counter
 @ %def mci_work_record_call
 @ %def mci_work_get_counter
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Process component manager}
 <<[[pcm.f90]]>>=
 <<File header>>
 
 module pcm
 
 <<Use kinds>>
 <<Use strings>>
   use constants, only: zero, two
   use diagnostics
   use lorentz
   use io_units, only: free_unit
   use process_constants, only: process_constants_t
   use physics_defs
   use model_data, only: model_data_t
   use interactions, only: interaction_t
   use quantum_numbers, only: quantum_numbers_t, quantum_numbers_mask_t
   use flavors, only: flavor_t
   use nlo_data, only: nlo_settings_t
   use phs_fks, only: isr_kinematics_t, real_kinematics_t
   use phs_fks, only: phs_identifier_t
   use fks_regions, only: region_data_t
   use phs_fks, only: phs_fks_generator_t
   use phs_fks, only: dalitz_plot_t
   use real_subtraction, only: real_subtraction_t, soft_mismatch_t
   use real_subtraction, only: FIXED_ORDER_EVENTS, POWHEG
   use real_subtraction, only: real_partition_t, powheg_damping_simple_t
   use real_subtraction, only: real_partition_fixed_order_t
   use virtual, only: virtual_t
   use dglap_remnant, only: dglap_remnant_t
 
   use pcm_base
 
 <<Standard module head>>
 
 <<Pcm: public>>
 
 <<Pcm: types>>
 
 contains
 
 <<Pcm: procedures>>
 
 end module pcm
 @ %def pcm
 \subsection{Default process component manager}
 This is the configuration object which has the duty of allocating the
 corresponding instance.  The default version is trivial.
 <<Pcm: public>>=
   public :: pcm_default_t
 <<Pcm: types>>=
   type, extends (pcm_t) :: pcm_default_t
    contains
    <<Pcm: pcm default: TBP>>
   end type pcm_default_t
 
 @ %def pcm_default_t
 <<Pcm: pcm default: TBP>>=
   procedure :: allocate_instance => pcm_default_allocate_instance
 <<Pcm: procedures>>=
   subroutine pcm_default_allocate_instance (pcm, instance)
     class(pcm_default_t), intent(in) :: pcm
     class(pcm_instance_t), intent(inout), allocatable :: instance
     allocate (pcm_instance_default_t :: instance)
   end subroutine pcm_default_allocate_instance
 
 @ %def pcm_default_allocate_instance
 @
 <<Pcm: pcm default: TBP>>=
   procedure :: final => pcm_default_final
 <<Pcm: procedures>>=
   subroutine pcm_default_final (pcm)
     class(pcm_default_t), intent(inout) :: pcm
   end subroutine pcm_default_final
 
 @ %def pcm_default_final
 @
 <<Pcm: pcm default: TBP>>=
   procedure :: is_nlo => pcm_default_is_nlo
 <<Pcm: procedures>>=
   function pcm_default_is_nlo (pcm) result (is_nlo)
     logical :: is_nlo
     class(pcm_default_t), intent(in) :: pcm
     is_nlo = .false.
   end function pcm_default_is_nlo
 
 @ %def pcm_default_is_nlo
 @
 <<Pcm: types>>=
   type, extends (pcm_instance_t) :: pcm_instance_default_t
   contains
   <<Pcm: pcm instance default: TBP>>
   end type pcm_instance_default_t
 
 @ %def pcm_instance_default_t
 @
 <<Pcm: pcm instance default: TBP>>=
   procedure :: final => pcm_instance_default_final
 <<Pcm: procedures>>=
   subroutine pcm_instance_default_final (pcm_instance)
     class(pcm_instance_default_t), intent(inout) :: pcm_instance
   end subroutine pcm_instance_default_final
 
 @ %def pcm_instance_default_final
 @
 \subsection{NLO process component manager}
 The NLO-aware version of the process-component manager.
 
 This is the configuration object, which has the duty of allocating the
 corresponding instance.  This is the nontrivial NLO version.
 <<Pcm: public>>=
   public :: pcm_nlo_t
 <<Pcm: types>>=
   type, extends (pcm_t) :: pcm_nlo_t
     type(nlo_settings_t) :: settings
     type(region_data_t) :: region_data
     class(real_partition_t), allocatable :: real_partition
     type(dalitz_plot_t) :: dalitz_plot
     type(quantum_numbers_t), dimension(:,:), allocatable :: qn_real, qn_born
   contains
   <<Pcm: pcm nlo: TBP>>
   end type pcm_nlo_t
 
 @ %def pcm_nlo_t
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: get_n_flv_born => pcm_nlo_get_n_flv_born
 <<Pcm: procedures>>=
   function pcm_nlo_get_n_flv_born (pcm_nlo) result (n_flv)
     integer :: n_flv
     class(pcm_nlo_t), intent(in) :: pcm_nlo
     n_flv = pcm_nlo%region_data%n_flv_born
   end function pcm_nlo_get_n_flv_born
 
 @ %def pcm_nlo_get_n_flv_born
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: get_n_flv_real => pcm_nlo_get_n_flv_real
 <<Pcm: procedures>>=
   function pcm_nlo_get_n_flv_real (pcm_nlo) result (n_flv)
     integer :: n_flv
     class(pcm_nlo_t), intent(in) :: pcm_nlo
     n_flv = pcm_nlo%region_data%n_flv_real
   end function pcm_nlo_get_n_flv_real
 
 @ %def pcm_nlo_get_n_flv_real
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: get_n_alr => pcm_nlo_get_n_alr
 <<Pcm: procedures>>=
   function pcm_nlo_get_n_alr (pcm) result (n_alr)
     integer :: n_alr
     class(pcm_nlo_t), intent(in) :: pcm
     n_alr = pcm%region_data%n_regions
   end function pcm_nlo_get_n_alr
 
 @ %def pcm_nlo_get_n_alr
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: get_flv_states => pcm_nlo_get_flv_states
 <<Pcm: procedures>>=
   function pcm_nlo_get_flv_states (pcm, born) result (flv)
     integer, dimension(:,:), allocatable :: flv
     class(pcm_nlo_t), intent(in) :: pcm
     logical, intent(in) :: born
     if (born) then
        flv = pcm%region_data%get_flv_states_born ()
     else
        flv = pcm%region_data%get_flv_states_real ()
     end if
   end function pcm_nlo_get_flv_states
 
 @ %def pcm_nlo_get_flv_states
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: get_qn => pcm_nlo_get_qn
 <<Pcm: procedures>>=
   function pcm_nlo_get_qn (pcm, born) result (qn)
     type(quantum_numbers_t), dimension(:,:), allocatable :: qn
     class(pcm_nlo_t), intent(in) :: pcm
     logical, intent(in) :: born
     if (born) then
        qn = pcm%qn_born
     else
        qn = pcm%qn_real
     end if
   end function pcm_nlo_get_qn
 
 @ %def pcm_nlo_get_qn
 @ Check if there are massive emitters. Since the mass-structure of all
 underlying Born configurations have to be the same (\textbf{This does
 not have to be the case when different components are generated at LO})
 , we just use the first one to determine this.
 <<Pcm: pcm nlo: TBP>>=
   procedure :: has_massive_emitter => pcm_nlo_has_massive_emitter
 <<Pcm: procedures>>=
   function pcm_nlo_has_massive_emitter (pcm) result (val)
     logical :: val
     class(pcm_nlo_t), intent(in) :: pcm
     integer :: i
     val = .false.
     associate (reg_data => pcm%region_data)
        do i = reg_data%n_in + 1, reg_data%n_legs_born
           if (any (i == reg_data%emitters)) &
              val = val .or. reg_data%flv_born(1)%massive(i)
        end do
     end associate
   end function pcm_nlo_has_massive_emitter
 
 @ %def pcm_nlo_has_massive_emitter
 @ Returns an array which specifies if the particle at position [[i]] is massive.
 <<Pcm: pcm nlo: TBP>>=
   procedure :: get_mass_info => pcm_nlo_get_mass_info
 <<Pcm: procedures>>=
   function pcm_nlo_get_mass_info (pcm, i_flv) result (massive)
     class(pcm_nlo_t), intent(in) :: pcm
     integer, intent(in) :: i_flv
     logical, dimension(:), allocatable :: massive
     allocate (massive (size (pcm%region_data%flv_born(i_flv)%massive)))
     massive = pcm%region_data%flv_born(i_flv)%massive
   end function pcm_nlo_get_mass_info
 
 @ %def pcm_nlo_get_mass_info
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: allocate_instance => pcm_nlo_allocate_instance
 <<Pcm: procedures>>=
   subroutine pcm_nlo_allocate_instance (pcm, instance)
     class(pcm_nlo_t), intent(in) :: pcm
     class(pcm_instance_t), intent(inout), allocatable :: instance
     allocate (pcm_instance_nlo_t :: instance)
   end subroutine pcm_nlo_allocate_instance
 
 @ %def pcm_nlo_allocate_instance
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: init_qn => pcm_nlo_init_qn
 <<Pcm: procedures>>=
   subroutine pcm_nlo_init_qn (pcm, model)
     class(pcm_nlo_t), intent(inout) :: pcm
     class(model_data_t), intent(in) :: model
     integer, dimension(:,:), allocatable :: flv_states
     type(flavor_t), dimension(:), allocatable :: flv
     integer :: i
     type(quantum_numbers_t), dimension(:), allocatable :: qn
     allocate (flv_states (pcm%region_data%n_legs_born, pcm%region_data%n_flv_born))
     flv_states = pcm%get_flv_states (.true.)
     allocate (pcm%qn_born (size (flv_states, dim = 1), size (flv_states, dim = 2)))
     allocate (flv (size (flv_states, dim = 1)))
     allocate (qn (size (flv_states, dim = 1)))
     do i = 1, pcm%get_n_flv_born ()
        call flv%init (flv_states (:,i), model)
        call qn%init (flv)
        pcm%qn_born(:,i) = qn
     end do
     deallocate (flv); deallocate (qn)
     deallocate (flv_states)
     allocate (flv_states (pcm%region_data%n_legs_real, pcm%region_data%n_flv_real))
     flv_states = pcm%get_flv_states (.false.)
     allocate (pcm%qn_real (size (flv_states, dim = 1), size (flv_states, dim = 2)))
     allocate (flv (size (flv_states, dim = 1)))
     allocate (qn (size (flv_states, dim = 1)))
     do i = 1, pcm%get_n_flv_real ()
        call flv%init (flv_states (:,i), model)
        call qn%init (flv)
        pcm%qn_real(:,i) = qn
     end do
   end subroutine pcm_nlo_init_qn
 
 @ %def pcm_nlo_init_qn
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: allocate_ps_matching => pcm_nlo_allocate_ps_matching
 <<Pcm: procedures>>=
   subroutine pcm_nlo_allocate_ps_matching (pcm)
     class(pcm_nlo_t), intent(inout) :: pcm
     if (.not. allocated (pcm%real_partition)) then
        allocate (powheg_damping_simple_t :: pcm%real_partition)
     end if
   end subroutine pcm_nlo_allocate_ps_matching
 
 @ %def pcm_nlo_allocate_ps_matching
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: activate_dalitz_plot => pcm_nlo_activate_dalitz_plot
 <<Pcm: procedures>>=
   subroutine pcm_nlo_activate_dalitz_plot (pcm, filename)
     class(pcm_nlo_t), intent(inout) :: pcm
     type(string_t), intent(in) :: filename
     call pcm%dalitz_plot%init (free_unit (), filename, .false.)
     call pcm%dalitz_plot%write_header ()
   end subroutine pcm_nlo_activate_dalitz_plot
 
 @ %def pcm_nlo_activate_dalitz_plot
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: setup_real_partition => pcm_nlo_setup_real_partition
 <<Pcm: procedures>>=
   subroutine pcm_nlo_setup_real_partition (pcm, scale)
     class(pcm_nlo_t), intent(inout) :: pcm
     real(default), intent(in) :: scale
     if (.not. allocated (pcm%real_partition)) then
        allocate (real_partition_fixed_order_t :: pcm%real_partition)
        select type (partition => pcm%real_partition)
        type is (real_partition_fixed_order_t)
           call pcm%region_data%get_all_ftuples (partition%fks_pairs)
           partition%scale = scale
        end select
     end if
   end subroutine pcm_nlo_setup_real_partition
 
 @ %def pcm_nlo_setup_real_partition
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: register_dalitz_plot => pcm_nlo_register_dalitz_plot
 <<Pcm: procedures>>=
   subroutine pcm_nlo_register_dalitz_plot (pcm, emitter, p)
     class(pcm_nlo_t), intent(inout) :: pcm
     integer, intent(in) :: emitter
     type(vector4_t), intent(in), dimension(:) :: p
     real(default) :: k0_n, k0_np1
     k0_n = p(emitter)%p(0)
     k0_np1 = p(size(p))%p(0)
     call pcm%dalitz_plot%register (k0_n, k0_np1)
   end subroutine pcm_nlo_register_dalitz_plot
 
 @ %def pcm_nlo_register_dalitz_plot
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: setup_phs_generator => pcm_nlo_setup_phs_generator
 <<Pcm: procedures>>=
   subroutine pcm_nlo_setup_phs_generator (pcm, pcm_instance, generator, &
      sqrts, mode, singular_jacobian)
     class(pcm_nlo_t), intent(in) :: pcm
     type(phs_fks_generator_t), intent(inout) :: generator
     type(pcm_instance_nlo_t), intent(in), target :: pcm_instance
     real(default), intent(in) :: sqrts
     integer, intent(in), optional:: mode
     logical, intent(in), optional :: singular_jacobian
     logical :: yorn
     yorn = .false.; if (present (singular_jacobian)) yorn = singular_jacobian
     call generator%connect_kinematics (pcm_instance%isr_kinematics, &
          pcm_instance%real_kinematics, pcm%has_massive_emitter ())
     generator%n_in = pcm%region_data%n_in
     call generator%set_sqrts_hat (sqrts)
     call generator%set_emitters (pcm%region_data%emitters)
     call generator%setup_masses (pcm%region_data%n_legs_born)
     generator%is_massive = pcm%get_mass_info (1)
     generator%singular_jacobian = yorn
     if (present (mode)) generator%mode = mode
   end subroutine pcm_nlo_setup_phs_generator
 
 @ %def pcm_nlo_setup_phs_generator
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: final => pcm_nlo_final
 <<Pcm: procedures>>=
   subroutine pcm_nlo_final (pcm)
     class(pcm_nlo_t), intent(inout) :: pcm
     if (allocated (pcm%real_partition)) deallocate (pcm%real_partition)
     call pcm%dalitz_plot%final ()
   end subroutine pcm_nlo_final
 
 @ %def pcm_nlo_final
 @
 <<Pcm: pcm nlo: TBP>>=
   procedure :: is_nlo => pcm_nlo_is_nlo
 <<Pcm: procedures>>=
   function pcm_nlo_is_nlo (pcm) result (is_nlo)
     logical :: is_nlo
     class(pcm_nlo_t), intent(in) :: pcm
     is_nlo = .true.
   end function pcm_nlo_is_nlo
 
 @ %def pcm_nlo_is_nlo
 @ As a first implementation, it acts as a wrapper for the NLO controller
 object and the squared matrix-element collector.
 <<Pcm: public>>=
   public :: pcm_instance_nlo_t
 <<Pcm: types>>=
   type, extends (pcm_instance_t) :: pcm_instance_nlo_t
      logical :: use_internal_color_correlation = .true.
      type(real_kinematics_t), pointer :: real_kinematics => null ()
      type(isr_kinematics_t), pointer :: isr_kinematics => null ()
      type(real_subtraction_t) :: real_sub
      type(virtual_t) :: virtual
      type(soft_mismatch_t) :: soft_mismatch
      type(dglap_remnant_t) :: dglap_remnant
      integer, dimension(:), allocatable :: i_mci_to_real_component
   contains
   <<Pcm: pcm instance: TBP>>
   end type pcm_instance_nlo_t
 
 @ %def pcm_instance_nlo_t
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: set_radiation_event => pcm_instance_nlo_set_radiation_event
   procedure :: set_subtraction_event => pcm_instance_nlo_set_subtraction_event
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_set_radiation_event (pcm_instance)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     pcm_instance%real_sub%radiation_event = .true.
     pcm_instance%real_sub%subtraction_event = .false.
   end subroutine pcm_instance_nlo_set_radiation_event
 
   subroutine pcm_instance_nlo_set_subtraction_event (pcm_instance)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     pcm_instance%real_sub%radiation_event = .false.
     pcm_instance%real_sub%subtraction_event = .true.
   end subroutine pcm_instance_nlo_set_subtraction_event
 
 @ %def pcm_instance_nlo_set_radiation_event
 @ %def pcm_instance_nlo_set_subtraction_event
 <<Pcm: pcm instance: TBP>>=
   procedure :: disable_subtraction => pcm_instance_nlo_disable_subtraction
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_disable_subtraction (pcm_instance)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     pcm_instance%real_sub%subtraction_deactivated = .true.
   end subroutine pcm_instance_nlo_disable_subtraction
 
 @ %def pcm_instance_nlo_disable_subtraction
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: init_config => pcm_instance_nlo_init_config
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_init_config (pcm_instance, active_components, &
      nlo_types, sqrts, i_real_fin, model)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     logical, intent(in), dimension(:) :: active_components
     integer, intent(in), dimension(:) :: nlo_types
     real(default), intent(in) :: sqrts
     integer, intent(in) :: i_real_fin
     class(model_data_t), intent(in) :: model
     integer :: i_component
     call msg_debug (D_PROCESS_INTEGRATION, "pcm_instance_nlo_init_config")
     call pcm_instance%init_real_and_isr_kinematics (sqrts)
     select type (pcm => pcm_instance%config)
     type is (pcm_nlo_t)
        do i_component = 1, size (active_components)
           if (active_components(i_component) .or. pcm%settings%combined_integration) then
              select case (nlo_types(i_component))
              case (NLO_REAL)
                 if (i_component /= i_real_fin) then
                    call pcm_instance%setup_real_component &
                         (pcm%settings%fks_template%subtraction_disabled)
                 end if
              case (NLO_VIRTUAL)
                 call pcm_instance%init_virtual (model)
              case (NLO_MISMATCH)
                 call pcm_instance%init_soft_mismatch ()
              case (NLO_DGLAP)
                 call pcm_instance%init_dglap_remnant ()
              end select
           end if
        end do
     end select
   end subroutine pcm_instance_nlo_init_config
 
 @ %def pcm_instance_nlo_init_config
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: setup_real_component => pcm_instance_nlo_setup_real_component
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_setup_real_component (pcm_instance, &
      subtraction_disabled)
     class(pcm_instance_nlo_t), intent(inout), target :: pcm_instance
     logical, intent(in) :: subtraction_disabled
     call pcm_instance%init_real_subtraction ()
     if (subtraction_disabled)  call pcm_instance%disable_subtraction ()
   end subroutine pcm_instance_nlo_setup_real_component
 
 @ %def pcm_instance_nlo_setup_real_component
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: init_real_and_isr_kinematics => &
        pcm_instance_nlo_init_real_and_isr_kinematics
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_init_real_and_isr_kinematics (pcm_instance, sqrts)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     real(default) :: sqrts
     integer :: n_contr
     allocate (pcm_instance%real_kinematics)
     allocate (pcm_instance%isr_kinematics)
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        associate (region_data => config%region_data)
           if (allocated (region_data%alr_contributors)) then
              n_contr = size (region_data%alr_contributors)
           else if (config%settings%factorization_mode == FACTORIZATION_THRESHOLD) then
              n_contr = 2
           else
              n_contr = 1
           end if
           call pcm_instance%real_kinematics%init &
                (region_data%n_legs_real, region_data%n_phs, &
                region_data%n_regions, n_contr)
           if (config%settings%factorization_mode == FACTORIZATION_THRESHOLD) &
              call pcm_instance%real_kinematics%init_onshell &
                   (region_data%n_legs_real, region_data%n_phs)
           pcm_instance%isr_kinematics%n_in = region_data%n_in
        end associate
     end select
     pcm_instance%isr_kinematics%beam_energy = sqrts / two
   end subroutine pcm_instance_nlo_init_real_and_isr_kinematics
 
 @ %def pcm_instance_nlo_init_real_and_isr_kinematics
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: set_real_and_isr_kinematics => &
       pcm_instance_nlo_set_real_and_isr_kinematics
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_set_real_and_isr_kinematics (pcm_instance, phs_identifiers, sqrts)
     class(pcm_instance_nlo_t), intent(inout), target :: pcm_instance
     type(phs_identifier_t), intent(in), dimension(:) :: phs_identifiers
     real(default), intent(in) :: sqrts
     call pcm_instance%real_sub%set_real_kinematics &
          (pcm_instance%real_kinematics)
     call pcm_instance%real_sub%set_isr_kinematics &
          (pcm_instance%isr_kinematics)
   end subroutine pcm_instance_nlo_set_real_and_isr_kinematics
 
 @ %def pcm_instance_nlo_set_real_and_isr_kinematics
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: init_real_subtraction => pcm_instance_nlo_init_real_subtraction
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_init_real_subtraction (pcm_instance)
     class(pcm_instance_nlo_t), intent(inout), target :: pcm_instance
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        associate (region_data => config%region_data)
           call pcm_instance%real_sub%init (region_data, config%settings)
           if (allocated (config%settings%selected_alr)) then
               associate (selected_alr => config%settings%selected_alr)
                 if (any (selected_alr < 0)) then
                    call msg_fatal ("Fixed alpha region must be non-negative!")
                 else if (any (selected_alr > region_data%n_regions)) then
                    call msg_fatal ("Fixed alpha region is larger than the total"&
                         &" number of singular regions!")
                 else
                    allocate (pcm_instance%real_sub%selected_alr (size (selected_alr)))
                    pcm_instance%real_sub%selected_alr = selected_alr
                 end if
              end associate
           end if
        end associate
     end select
   end subroutine pcm_instance_nlo_init_real_subtraction
 
 @ %def pcm_instance_nlo_init_real_subtraction
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: set_momenta_and_scales_virtual => &
      pcm_instance_nlo_set_momenta_and_scales_virtual
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_set_momenta_and_scales_virtual (pcm_instance, p, &
      ren_scale, fac_scale)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     type(vector4_t), intent(in), dimension(:) :: p
     real(default), intent(in) :: ren_scale, fac_scale
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        associate (virtual => pcm_instance%virtual)
           call virtual%set_ren_scale (p, ren_scale)
           call virtual%set_fac_scale (p, fac_scale)
           call virtual%set_ellis_sexton_scale ()
        end associate
     end select
   end subroutine pcm_instance_nlo_set_momenta_and_scales_virtual
 
 @ %def pcm_instance_nlo_set_momenta_and_scales_virtual
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: set_fac_scale => pcm_instance_nlo_set_fac_scale
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_set_fac_scale (pcm_instance, fac_scale)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     real(default), intent(in) :: fac_scale
     pcm_instance%isr_kinematics%fac_scale = fac_scale
   end subroutine pcm_instance_nlo_set_fac_scale
 
 @ %def pcm_instance_nlo_set_fac_scale
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: set_momenta => pcm_instance_nlo_set_momenta
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_set_momenta (pcm_instance, p_born, p_real, i_phs, cms)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     type(vector4_t), dimension(:), intent(in) :: p_born, p_real
     integer, intent(in) :: i_phs
     logical, intent(in), optional :: cms
     logical :: yorn
     yorn = .false.; if (present (cms)) yorn = cms
     associate (kinematics => pcm_instance%real_kinematics)
        if (yorn) then
           if (.not. kinematics%p_born_cms%initialized) &
                call kinematics%p_born_cms%init (size (p_born), 1)
           if (.not. kinematics%p_real_cms%initialized) &
                call kinematics%p_real_cms%init (size (p_real), 1)
           kinematics%p_born_cms%phs_point(1)%p = p_born
           kinematics%p_real_cms%phs_point(i_phs)%p = p_real
        else
           if (.not. kinematics%p_born_lab%initialized) &
                call kinematics%p_born_lab%init (size (p_born), 1)
           if (.not. kinematics%p_real_lab%initialized) &
                call kinematics%p_real_lab%init (size (p_real), 1)
           kinematics%p_born_lab%phs_point(1)%p = p_born
           kinematics%p_real_lab%phs_point(i_phs)%p = p_real
        end if
     end associate
   end subroutine pcm_instance_nlo_set_momenta
 
 @ %def pcm_instance_nlo_set_momenta
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: get_momenta => pcm_instance_nlo_get_momenta
 <<Pcm: procedures>>=
   function pcm_instance_nlo_get_momenta (pcm_instance, i_phs, born_phsp, cms) result (p)
     type(vector4_t), dimension(:), allocatable :: p
     class(pcm_instance_nlo_t), intent(in) :: pcm_instance
     integer, intent(in) :: i_phs
     logical, intent(in) :: born_phsp
     logical, intent(in), optional :: cms
     logical :: yorn
     yorn = .false.; if (present (cms)) yorn = cms
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        if (born_phsp) then
           if (yorn) then
              allocate (p (1 : config%region_data%n_legs_born), &
                 source = pcm_instance%real_kinematics%p_born_cms%phs_point(1)%p)
           else
              allocate (p (1 : config%region_data%n_legs_born), &
                 source = pcm_instance%real_kinematics%p_born_lab%phs_point(1)%p)
           end if
        else
           if (yorn) then
              allocate (p (1 : config%region_data%n_legs_real), &
                 source = pcm_instance%real_kinematics%p_real_cms%phs_point(i_phs)%p)
           else
              allocate (p ( 1 : config%region_data%n_legs_real), &
                   source = pcm_instance%real_kinematics%p_real_lab%phs_point(i_phs)%p)
           end if
        end if
     end select
   end function pcm_instance_nlo_get_momenta
 
 @ %def pcm_instance_nlo_get_momenta
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: get_xi_max => pcm_instance_nlo_get_xi_max
 <<Pcm: procedures>>=
   function pcm_instance_nlo_get_xi_max (pcm_instance, alr) result (xi_max)
     real(default) :: xi_max
     class(pcm_instance_nlo_t), intent(in) :: pcm_instance
     integer, intent(in) :: alr
     integer :: i_phs
     i_phs = pcm_instance%real_kinematics%alr_to_i_phs (alr)
     xi_max = pcm_instance%real_kinematics%xi_max (i_phs)
   end function pcm_instance_nlo_get_xi_max
 
 @ %def pcm_instance_nlo_get_xi_max
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: get_n_born => pcm_instance_nlo_get_n_born
 <<Pcm: procedures>>=
   function pcm_instance_nlo_get_n_born (pcm_instance) result (n_born)
     integer :: n_born
     class(pcm_instance_nlo_t), intent(in) :: pcm_instance
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        n_born = config%region_data%n_legs_born
     end select
   end function pcm_instance_nlo_get_n_born
 
 @ %def pcm_instance_nlo_get_n_born
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: get_n_real => pcm_instance_nlo_get_n_real
 <<Pcm: procedures>>=
   function pcm_instance_nlo_get_n_real (pcm_instance) result (n_real)
     integer :: n_real
     class(pcm_instance_nlo_t), intent(in) :: pcm_instance
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        n_real = config%region_data%n_legs_real
     end select
   end function pcm_instance_nlo_get_n_real
 
 @ %def pcm_instance_nlo_get_n_real
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: get_n_regions => pcm_instance_nlo_get_n_regions
 <<Pcm: procedures>>=
   function pcm_instance_nlo_get_n_regions (pcm_instance) result (n_regions)
     integer :: n_regions
     class(pcm_instance_nlo_t), intent(in) :: pcm_instance
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        n_regions = config%region_data%n_regions
     end select
   end function pcm_instance_nlo_get_n_regions
 
 @ %def pcm_instance_nlo_get_n_regions
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: set_x_rad => pcm_instance_nlo_set_x_rad
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_set_x_rad (pcm_instance, x_tot)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     real(default), intent(in), dimension(:) :: x_tot
     integer :: n_par
     n_par = size (x_tot)
     if (n_par < 3) then
        pcm_instance%real_kinematics%x_rad = zero
     else
        pcm_instance%real_kinematics%x_rad = x_tot (n_par - 2 : n_par)
     end if
   end subroutine pcm_instance_nlo_set_x_rad
 
 @ %def pcm_instance_nlo_set_x_rad
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: init_virtual => pcm_instance_nlo_init_virtual
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_init_virtual (pcm_instance, model)
     class(pcm_instance_nlo_t), intent(inout), target :: pcm_instance
     class(model_data_t), intent(in) :: model
     type(nlo_settings_t), pointer :: settings
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        associate (region_data => config%region_data)
          settings => config%settings
          call pcm_instance%virtual%init (region_data%get_flv_states_born (), &
               region_data%n_in, settings, &
               region_data%regions(1)%nlo_correction_type, model, config%has_pdfs)
        end associate
     end select
   end subroutine pcm_instance_nlo_init_virtual
 
 @ %def pcm_instance_nlo_init_virtual
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: disable_virtual_subtraction => pcm_instance_nlo_disable_virtual_subtraction
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_disable_virtual_subtraction (pcm_instance)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
   end subroutine pcm_instance_nlo_disable_virtual_subtraction
 
 @ %def pcm_instance_nlo_disable_virtual_subtraction
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: compute_sqme_virt => pcm_instance_nlo_compute_sqme_virt
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_compute_sqme_virt (pcm_instance, p, &
          alpha_coupling, separate_alrs, sqme_virt)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     type(vector4_t), intent(in), dimension(:) :: p
     real(default), intent(in) :: alpha_coupling
     logical, intent(in) :: separate_alrs
     real(default), dimension(:), allocatable, intent(inout) :: sqme_virt
     type(vector4_t), dimension(:), allocatable :: pp
     associate (virtual => pcm_instance%virtual)
        allocate (pp (size (p)))
        if (virtual%settings%factorization_mode == FACTORIZATION_THRESHOLD) then
           pp = pcm_instance%real_kinematics%p_born_onshell%get_momenta (1)
        else
           pp = p
        end if
        select type (config => pcm_instance%config)
        type is (pcm_nlo_t)
           if (separate_alrs) then
              allocate (sqme_virt (config%get_n_flv_born ()))
           else
              allocate (sqme_virt (1))
           end if
           sqme_virt = zero
           call virtual%evaluate (config%region_data, &
                alpha_coupling, pp, separate_alrs, sqme_virt)
        end select
     end associate
   end subroutine pcm_instance_nlo_compute_sqme_virt
 
 @ %def pcm_instance_nlo_compute_sqme_virt
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: compute_sqme_mismatch => pcm_instance_nlo_compute_sqme_mismatch
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_compute_sqme_mismatch (pcm_instance, &
            alpha_s, separate_alrs, sqme_mism)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     real(default), intent(in) :: alpha_s
     logical, intent(in) :: separate_alrs
     real(default), dimension(:), allocatable, intent(inout) :: sqme_mism
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        if (separate_alrs) then
           allocate (sqme_mism (config%get_n_flv_born ()))
        else
           allocate (sqme_mism (1))
        end if
        sqme_mism = zero
        sqme_mism = pcm_instance%soft_mismatch%evaluate (alpha_s)
     end select
   end subroutine pcm_instance_nlo_compute_sqme_mismatch
 
 @ %def pcm_instance_nlo_compute_sqme_mismatch
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: compute_sqme_dglap_remnant => pcm_instance_nlo_compute_sqme_dglap_remnant
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_compute_sqme_dglap_remnant (pcm_instance, &
             alpha_s, separate_alrs, sqme_dglap)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     real(default), intent(in) :: alpha_s
     logical, intent(in) :: separate_alrs
     real(default), dimension(:), allocatable, intent(inout) :: sqme_dglap
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        if (separate_alrs) then
           allocate (sqme_dglap (config%get_n_flv_born ()))
        else
           allocate (sqme_dglap (1))
        end if
     end select
     sqme_dglap = zero
     call pcm_instance%dglap_remnant%evaluate (alpha_s, separate_alrs, sqme_dglap)
   end subroutine pcm_instance_nlo_compute_sqme_dglap_remnant
 
 @ %def pcm_instance_nlo_compute_sqme_dglap_remnant
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: set_fixed_order_event_mode => pcm_instance_nlo_set_fixed_order_event_mode
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_set_fixed_order_event_mode (pcm_instance)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     pcm_instance%real_sub%purpose = FIXED_ORDER_EVENTS
   end subroutine pcm_instance_nlo_set_fixed_order_event_mode
 
 <<Pcm: pcm instance: TBP>>=
   procedure :: set_powheg_mode => pcm_instance_nlo_set_powheg_mode
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_set_powheg_mode (pcm_instance)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     pcm_instance%real_sub%purpose = POWHEG
   end subroutine pcm_instance_nlo_set_powheg_mode
 
 @ %def pcm_instance_nlo_set_fixed_order_event_mode
 @ %def pcm_instance_nlo_set_powheg_mode
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: init_soft_mismatch => pcm_instance_nlo_init_soft_mismatch
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_init_soft_mismatch (pcm_instance)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        call pcm_instance%soft_mismatch%init (config%region_data, &
             pcm_instance%real_kinematics, config%settings%factorization_mode)
     end select
   end subroutine pcm_instance_nlo_init_soft_mismatch
 
 @ %def pcm_instance_nlo_init_soft_mismatch
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: init_dglap_remnant => pcm_instance_nlo_init_dglap_remnant
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_init_dglap_remnant (pcm_instance)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        call pcm_instance%dglap_remnant%init ( &
             config%settings, &
             config%region_data%n_flv_born, &
             pcm_instance%isr_kinematics, &
             config%region_data%get_flv_states_born (), config%get_n_alr ())
     end select
   end subroutine pcm_instance_nlo_init_dglap_remnant
 
 @ %def pcm_instance_nlo_init_dglap_remnant
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: is_fixed_order_nlo_events &
        => pcm_instance_nlo_is_fixed_order_nlo_events
 <<Pcm: procedures>>=
   function pcm_instance_nlo_is_fixed_order_nlo_events (pcm_instance) result (is_nlo)
     logical :: is_nlo
     class(pcm_instance_nlo_t), intent(in) :: pcm_instance
     is_nlo = pcm_instance%real_sub%purpose == FIXED_ORDER_EVENTS
   end function pcm_instance_nlo_is_fixed_order_nlo_events
 
 @ %def pcm_instance_nlo_is_fixed_order_nlo_events
 @
 <<Pcm: pcm instance: TBP>>=
   procedure :: final => pcm_instance_nlo_final
 <<Pcm: procedures>>=
   subroutine pcm_instance_nlo_final (pcm_instance)
     class(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     call pcm_instance%real_sub%final ()
     call pcm_instance%virtual%final ()
     call pcm_instance%soft_mismatch%final ()
     call pcm_instance%dglap_remnant%final ()
     if (associated (pcm_instance%real_kinematics)) then
        call pcm_instance%real_kinematics%final ()
        nullify (pcm_instance%real_kinematics)
     end if
     if (associated (pcm_instance%isr_kinematics)) then
        nullify (pcm_instance%isr_kinematics)
     end if
   end subroutine pcm_instance_nlo_final
 
 @ %def pcm_instance_nlo_final
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Kinematics instance}
 In this data type we combine all objects (instances) necessary for
 generating (or recovering) a kinematical configuration.  The
 components work together as an implementation of multi-channel phase
 space.
 
 [[sf_chain]] is an instance of the structure-function chain.  It is
 used both for generating kinematics and, after the proper scale has
 been determined, evaluating the structure function entries.
 
 [[phs]] is an instance of the phase space for the elementary process.
 
 The array [[f]] contains the products of the Jacobians that originate
 from parameter mappings in the structure-function chain or in the
 phase space.  We allocate this explicitly if either [[sf_chain]] or
 [[phs]] are explicitly allocated, otherwise we can take over a pointer.
 
 All components are implemented as pointers to (anonymous) targets.
 For each component, there is a flag that tells whether this component
 is to be regarded as a proper component (`owned' by the object) or as
 a pointer.
 @
 <<[[kinematics.f90]]>>=
 <<File header>>
 
 module kinematics
 
 <<Use kinds>>
   use format_utils, only: write_separator
   use diagnostics
   use io_units
   use lorentz
   use physics_defs
   use sf_base
   use phs_base
   use interactions
   use mci_base
   use phs_fks
   use fks_regions
   use process_config
   use process_mci
   use pcm, only: pcm_instance_nlo_t
   use ttv_formfactors, only: m1s_to_mpole
 
 <<Standard module head>>
 
 <<Kinematics: public>>
 
 <<Kinematics: types>>
 
 contains
 
 <<Kinematics: procedures>>
 
 end module kinematics
 @ %def kinematics
 <<Kinematics: public>>=
   public :: kinematics_t
 <<Kinematics: types>>=
   type :: kinematics_t
      integer :: n_in = 0
      integer :: n_channel = 0
      integer :: selected_channel = 0
      type(sf_chain_instance_t), pointer :: sf_chain => null ()
      class(phs_t), pointer :: phs => null ()
      real(default), dimension(:), pointer :: f => null ()
      real(default) :: phs_factor
      logical :: sf_chain_allocated = .false.
      logical :: phs_allocated = .false.
      logical :: f_allocated = .false.
      integer :: emitter = -1
      integer :: i_phs = 0
      integer :: i_con = 0
      logical :: only_cm_frame = .false.
      logical :: new_seed = .true.
      logical :: threshold = .false.
    contains
    <<Kinematics: kinematics: TBP>>
   end type kinematics_t
 
 @ %def kinematics_t
 @ Output.  Show only those components which are marked as owned.
 <<Kinematics: kinematics: TBP>>=
   procedure :: write => kinematics_write
 <<Kinematics: procedures>>=
   subroutine kinematics_write (object, unit)
     class(kinematics_t), intent(in) :: object
     integer, intent(in), optional :: unit
     integer :: u, c
     u = given_output_unit (unit)
     if (object%f_allocated) then
        write (u, "(1x,A)")  "Flux * PHS volume:"
        write (u, "(2x,ES19.12)")  object%phs_factor
        write (u, "(1x,A)")  "Jacobian factors per channel:"
        do c = 1, size (object%f)
           write (u, "(3x,I0,':',1x,ES14.7)", advance="no")  c, object%f(c)
           if (c == object%selected_channel) then
              write (u, "(1x,A)")  "[selected]"
           else
              write (u, *)
           end if
        end do
     end if
     if (object%sf_chain_allocated) then
        call write_separator (u)
        call object%sf_chain%write (u)
     end if
     if (object%phs_allocated) then
        call write_separator (u)
        call object%phs%write (u)
     end if
   end subroutine kinematics_write
 
 @ %def kinematics_write
 @ Finalizer.  Delete only those components which are marked as owned.
 <<Kinematics: kinematics: TBP>>=
   procedure :: final => kinematics_final
 <<Kinematics: procedures>>=
   subroutine kinematics_final (object)
     class(kinematics_t), intent(inout) :: object
     if (object%sf_chain_allocated) then
        call object%sf_chain%final ()
        deallocate (object%sf_chain)
        object%sf_chain_allocated = .false.
     end if
     if (object%phs_allocated) then
        call object%phs%final ()
        deallocate (object%phs)
        object%phs_allocated = .false.
     end if
     if (object%f_allocated) then
        deallocate (object%f)
        object%f_allocated = .false.
     end if
   end subroutine kinematics_final
 
 @ %def kinematics_final
 @ Set the flags indicating whether the phase space shall be set up for the calculation of the real contribution. For this case, also set the emitter.
 <<Kinematics: kinematics: TBP>>=
   procedure :: set_nlo_info => kinematics_set_nlo_info
 <<Kinematics: procedures>>=
   subroutine kinematics_set_nlo_info (k, nlo_type)
     class(kinematics_t), intent(inout) :: k
     integer, intent(in) :: nlo_type
     if (nlo_type == NLO_VIRTUAL)  k%only_cm_frame = .true.
   end subroutine kinematics_set_nlo_info
 
 @ %def kinematics_set_nlo_info
 @ Allocate the structure-function chain instance, initialize it as a
 copy of the [[sf_chain]] template, and prepare it for evaluation.
 
 The [[sf_chain]] remains a target because the (usually constant) beam momenta
 are taken from there.
 <<Kinematics: kinematics: TBP>>=
   procedure :: init_sf_chain => kinematics_init_sf_chain
 <<Kinematics: procedures>>=
   subroutine kinematics_init_sf_chain (k, sf_chain, config, extended_sf)
     class(kinematics_t), intent(inout) :: k
     type(sf_chain_t), intent(in), target :: sf_chain
     type(process_beam_config_t), intent(in) :: config
     logical, intent(in), optional :: extended_sf
     integer :: n_strfun, n_channel
     integer :: c
     k%n_in = config%data%get_n_in ()
     n_strfun = config%n_strfun
     n_channel = config%n_channel
     allocate (k%sf_chain)
     k%sf_chain_allocated = .true.
     call k%sf_chain%init (sf_chain, n_channel)
     if (n_strfun /= 0) then
        do c = 1, n_channel
           call k%sf_chain%set_channel (c, config%sf_channel(c))
        end do
     end if
     call k%sf_chain%link_interactions ()
     call k%sf_chain%exchange_mask ()
     call k%sf_chain%init_evaluators (extended_sf = extended_sf)
   end subroutine kinematics_init_sf_chain
 
 @ %def kinematics_init_sf_chain
 @ Allocate and initialize the phase-space part and the array of
 Jacobian factors.
 <<Kinematics: kinematics: TBP>>=
   procedure :: init_phs => kinematics_init_phs
 <<Kinematics: procedures>>=
   subroutine kinematics_init_phs (k, config)
     class(kinematics_t), intent(inout) :: k
     class(phs_config_t), intent(in), target :: config
     k%n_channel = config%get_n_channel ()
     call config%allocate_instance (k%phs)
     call k%phs%init (config)
     k%phs_allocated = .true.
     allocate (k%f (k%n_channel))
     k%f = 0
     k%f_allocated = .true.
   end subroutine kinematics_init_phs
 
 @ %def kinematics_init_phs
 @
 <<Kinematics: kinematics: TBP>>=
   procedure :: evaluate_radiation_kinematics => kinematics_evaluate_radiation_kinematics
 <<Kinematics: procedures>>=
   subroutine kinematics_evaluate_radiation_kinematics (k, r_in)
     class(kinematics_t), intent(inout) :: k
     real(default), intent(in), dimension(:) :: r_in
     select type (phs => k%phs)
     type is (phs_fks_t)
        call phs%generate_radiation_variables &
             (r_in(phs%n_r_born + 1 : phs%n_r_born + 3), k%threshold)
        call phs%compute_cms_energy ()
     end select
   end subroutine kinematics_evaluate_radiation_kinematics
 
 @ %def kinematics_evaluate_radiation_kinematics
 @
 <<Kinematics: kinematics: TBP>>=
   procedure :: compute_xi_ref_momenta => kinematics_compute_xi_ref_momenta
 <<Kinematics: procedures>>=
   subroutine kinematics_compute_xi_ref_momenta (k, reg_data, nlo_type)
     class(kinematics_t), intent(inout) :: k
     type(region_data_t), intent(in) :: reg_data
     integer, intent(in) :: nlo_type
     logical :: use_contributors
     use_contributors = allocated (reg_data%alr_contributors)
     select type (phs => k%phs)
     type is (phs_fks_t)
        if (use_contributors) then
           call phs%compute_xi_ref_momenta (contributors = reg_data%alr_contributors)
        else if (k%threshold) then
           if (.not. is_subtraction_component (k%emitter, nlo_type)) &
                call phs%compute_xi_ref_momenta_threshold ()
        else
           call phs%compute_xi_ref_momenta ()
        end if
     end select
   end subroutine kinematics_compute_xi_ref_momenta
 
 @ %def kinematics_compute_xi_ref_momenta
 @ Generate kinematics, given a phase-space channel and a MC
 parameter set. The main result is the momentum array [[p]], but we
 also fill the momentum entries in the structure-function chain and the
 Jacobian-factor array [[f]].  Regarding phase space, We fill only the
 parameter arrays for the selected channel.
 <<Kinematics: kinematics: TBP>>=
   procedure :: compute_selected_channel => kinematics_compute_selected_channel
 <<Kinematics: procedures>>=
   subroutine kinematics_compute_selected_channel &
        (k, mci_work, phs_channel, p, success)
     class(kinematics_t), intent(inout) :: k
     type(mci_work_t), intent(in) :: mci_work
     integer, intent(in) :: phs_channel
     type(vector4_t), dimension(:), intent(out) :: p
     logical, intent(out) :: success
     integer :: sf_channel
     k%selected_channel = phs_channel
     sf_channel = k%phs%config%get_sf_channel (phs_channel)
     call k%sf_chain%compute_kinematics (sf_channel, mci_work%get_x_strfun ())
     call k%sf_chain%get_out_momenta (p(1:k%n_in))
     call k%phs%set_incoming_momenta (p(1:k%n_in))
     call k%phs%compute_flux ()
     call k%phs%select_channel (phs_channel)
     call k%phs%evaluate_selected_channel (phs_channel, &
          mci_work%get_x_process ())
 
     select type (phs => k%phs)
     type is (phs_fks_t)
       if (phs%q_defined) then
          call phs%get_born_momenta (p)
          k%phs_factor = phs%get_overall_factor ()
          success = .true.
       else
          k%phs_factor = 0
          success = .false.
       end if
     class default
       if (phs%q_defined) then
          call k%phs%get_outgoing_momenta (p(k%n_in + 1 :))
          k%phs_factor = k%phs%get_overall_factor ()
          success = .true.
          if (k%only_cm_frame) then
             if (.not. k%lab_is_cm_frame()) &
                call k%boost_to_cm_frame (p)
          end if
       else
          k%phs_factor = 0
          success = .false.
       end if
     end select
   end subroutine kinematics_compute_selected_channel
 
 @ %def kinematics_compute_selected_channel
 @ Complete kinematics by filling the non-selected phase-space parameter
 arrays.
 <<Kinematics: kinematics: TBP>>=
   procedure :: compute_other_channels => kinematics_compute_other_channels
 <<Kinematics: procedures>>=
   subroutine kinematics_compute_other_channels (k, mci_work, phs_channel)
     class(kinematics_t), intent(inout) :: k
     type(mci_work_t), intent(in) :: mci_work
     integer, intent(in) :: phs_channel
     integer :: c, c_sf
     call k%phs%evaluate_other_channels (phs_channel)
     do c = 1, k%n_channel
        c_sf = k%phs%config%get_sf_channel (c)
        k%f(c) = k%sf_chain%get_f (c_sf) * k%phs%get_f (c)
     end do
   end subroutine kinematics_compute_other_channels
 
 @ %def kinematics_compute_other_channels
 @ Just fetch the outgoing momenta of the [[sf_chain]] subobject, which
 become the incoming (seed) momenta of the hard interaction.
 
 This is a stripped down-version of the above which we use when
 recovering kinematics.  Momenta are known, but no MC parameters yet.
 
 (We do not use the [[get_out_momenta]] method of the chain, since this
 relies on the structure-function interactions, which are not necessary
 filled here.  We do rely on the momenta of the last evaluator in the
 chain, however.)
 <<Kinematics: kinematics: TBP>>=
   procedure :: get_incoming_momenta => kinematics_get_incoming_momenta
 <<Kinematics: procedures>>=
   subroutine kinematics_get_incoming_momenta (k, p)
     class(kinematics_t), intent(in) :: k
     type(vector4_t), dimension(:), intent(out) :: p
     type(interaction_t), pointer :: int
     integer :: i
     int => k%sf_chain%get_out_int_ptr ()
     do i = 1, k%n_in
        p(i) = int%get_momentum (k%sf_chain%get_out_i (i))
     end do
   end subroutine kinematics_get_incoming_momenta
 
 @ %def kinematics_get_incoming_momenta
 @ This inverts the remainder of the above [[compute]] method.  We know
 the momenta and recover the rest, as far as needed.  If we select a
 channel, we can complete the inversion and reconstruct the
 MC parameter set.
 <<Kinematics: kinematics: TBP>>=
   procedure :: recover_mcpar => kinematics_recover_mcpar
 <<Kinematics: procedures>>=
   subroutine kinematics_recover_mcpar (k, mci_work, phs_channel, p)
     class(kinematics_t), intent(inout) :: k
     type(mci_work_t), intent(inout) :: mci_work
     integer, intent(in) :: phs_channel
     type(vector4_t), dimension(:), intent(in) :: p
     integer :: c, c_sf
     real(default), dimension(:), allocatable :: x_sf, x_phs
     c = phs_channel
     c_sf = k%phs%config%get_sf_channel (c)
     k%selected_channel = c
     call k%sf_chain%recover_kinematics (c_sf)
     call k%phs%set_incoming_momenta (p(1:k%n_in))
     call k%phs%compute_flux ()
     call k%phs%set_outgoing_momenta (p(k%n_in+1:))
     call k%phs%inverse ()
     do c = 1, k%n_channel
        c_sf = k%phs%config%get_sf_channel (c)
        k%f(c) = k%sf_chain%get_f (c_sf) * k%phs%get_f (c)
     end do
     k%phs_factor = k%phs%get_overall_factor ()
     c = phs_channel
     c_sf = k%phs%config%get_sf_channel (c)
     allocate (x_sf (k%sf_chain%config%get_n_bound ()))
     allocate (x_phs (k%phs%config%get_n_par ()))
     call k%phs%select_channel (c)
     call k%sf_chain%get_mcpar (c_sf, x_sf)
     call k%phs%get_mcpar (c, x_phs)
     call mci_work%set_x_strfun (x_sf)
     call mci_work%set_x_process (x_phs)
   end subroutine kinematics_recover_mcpar
 
 @ %def kinematics_recover_mcpar
 @ This first part of [[recover_mcpar]]: just handle the sfchain.
 <<Kinematics: kinematics: TBP>>=
   procedure :: recover_sfchain => kinematics_recover_sfchain
 <<Kinematics: procedures>>=
   subroutine kinematics_recover_sfchain (k, channel, p)
     class(kinematics_t), intent(inout) :: k
     integer, intent(in) :: channel
     type(vector4_t), dimension(:), intent(in) :: p
     k%selected_channel = channel
     call k%sf_chain%recover_kinematics (channel)
   end subroutine kinematics_recover_sfchain
 
 @ %def kinematics_recover_sfchain
 @ Retrieve the MC input parameter array for a specific channel.  We assume
 that the kinematics is complete, so this is known for all channels.
 <<Kinematics: kinematics: TBP>>=
   procedure :: get_mcpar => kinematics_get_mcpar
 <<Kinematics: procedures>>=
   subroutine kinematics_get_mcpar (k, phs_channel, r)
     class(kinematics_t), intent(in) :: k
     integer, intent(in) :: phs_channel
     real(default), dimension(:), intent(out) :: r
     integer :: sf_channel, n_par_sf, n_par_phs
     sf_channel = k%phs%config%get_sf_channel (phs_channel)
     n_par_phs = k%phs%config%get_n_par ()
     n_par_sf = k%sf_chain%config%get_n_bound ()
     if (n_par_sf > 0) then
        call k%sf_chain%get_mcpar (sf_channel, r(1:n_par_sf))
     end if
     if (n_par_phs > 0) then
        call k%phs%get_mcpar (phs_channel, r(n_par_sf+1:))
     end if
   end subroutine kinematics_get_mcpar
 
 @ %def kinematics_get_mcpar
 @ Evaluate the structure function chain, assuming that kinematics is known.
 
 The status must be precisely [[SF_DONE_KINEMATICS]].  We thus avoid
 evaluating the chain twice via different pointers to the same target.
 <<Kinematics: kinematics: TBP>>=
   procedure :: evaluate_sf_chain => kinematics_evaluate_sf_chain
 <<Kinematics: procedures>>=
   subroutine kinematics_evaluate_sf_chain (k, fac_scale, sf_rescale)
     class(kinematics_t), intent(inout) :: k
     real(default), intent(in) :: fac_scale
     class(sf_rescale_t), intent(inout), optional :: sf_rescale
     select case (k%sf_chain%get_status ())
     case (SF_DONE_KINEMATICS)
        call k%sf_chain%evaluate (fac_scale, sf_rescale)
     end select
   end subroutine kinematics_evaluate_sf_chain
 
 @ %def kinematics_evaluate_sf_chain
 @ Recover beam momenta, i.e., return the beam momenta stored in the
 current [[sf_chain]] to their source.  This is a side effect.
 <<Kinematics: kinematics: TBP>>=
   procedure :: return_beam_momenta => kinematics_return_beam_momenta
 <<Kinematics: procedures>>=
   subroutine kinematics_return_beam_momenta (k)
     class(kinematics_t), intent(in) :: k
     call k%sf_chain%return_beam_momenta ()
   end subroutine kinematics_return_beam_momenta
 
 @ %def kinematics_return_beam_momenta
 @ Check wether the phase space is configured in the center-of-mass frame.
 Relevant for using the proper momenta input for BLHA matrix elements.
 <<Kinematics: kinematics: TBP>>=
   procedure :: lab_is_cm_frame => kinematics_lab_is_cm_frame
 <<Kinematics: procedures>>=
   function kinematics_lab_is_cm_frame (k) result (cm_frame)
      logical :: cm_frame
      class(kinematics_t), intent(in) :: k
      cm_frame = k%phs%config%cm_frame
   end function kinematics_lab_is_cm_frame
 
 @ %def kinematics_lab_is_cm_frame
 @ Boost to center-of-mass frame
 <<Kinematics: kinematics: TBP>>=
   procedure :: boost_to_cm_frame => kinematics_boost_to_cm_frame
 <<Kinematics: procedures>>=
   subroutine kinematics_boost_to_cm_frame (k, p)
      class(kinematics_t), intent(in) :: k
      type(vector4_t), intent(inout), dimension(:) :: p
      p = inverse (k%phs%lt_cm_to_lab) * p
   end subroutine kinematics_boost_to_cm_frame
 
 @ %def kinematics_boost_to_cm_frame
 @
 <<Kinematics: kinematics: TBP>>=
   procedure :: modify_momenta_for_subtraction => kinematics_modify_momenta_for_subtraction
 <<Kinematics: procedures>>=
   subroutine kinematics_modify_momenta_for_subtraction (k, p_in, p_out)
     class(kinematics_t), intent(inout) :: k
     type(vector4_t), intent(in), dimension(:) :: p_in
     type(vector4_t), intent(out), dimension(:), allocatable :: p_out
     allocate (p_out (size (p_in)))
     if (k%threshold) then
        select type (phs => k%phs)
        type is (phs_fks_t)
           p_out = phs%get_onshell_projected_momenta ()
        end select
     else
        p_out = p_in
     end if
   end subroutine kinematics_modify_momenta_for_subtraction
 
 @ %def kinematics_modify_momenta_for_subtraction
 @
 <<Kinematics: kinematics: TBP>>=
   procedure :: threshold_projection => kinematics_threshold_projection
 <<Kinematics: procedures>>=
   subroutine kinematics_threshold_projection (k, pcm_instance, nlo_type)
     class(kinematics_t), intent(inout) :: k
     type(pcm_instance_nlo_t), intent(inout) :: pcm_instance
     integer, intent(in) :: nlo_type
     real(default) :: sqrts, mtop
     type(lorentz_transformation_t) :: L_to_cms
     type(vector4_t), dimension(:), allocatable :: p_tot
     integer :: n_tot
     n_tot = k%phs%get_n_tot ()
     allocate (p_tot (size (pcm_instance%real_kinematics%p_born_cms%phs_point(1)%p)))
     select type (phs => k%phs)
     type is (phs_fks_t)
        p_tot = pcm_instance%real_kinematics%p_born_cms%phs_point(1)%p
     class default
        p_tot(1 : k%n_in) = phs%p
        p_tot(k%n_in + 1 : n_tot) = phs%q
     end select
     sqrts = sum (p_tot (1:k%n_in))**1
     mtop = m1s_to_mpole (sqrts)
     L_to_cms = get_boost_for_threshold_projection (p_tot, sqrts, mtop)
     call pcm_instance%real_kinematics%p_born_cms%set_momenta (1, p_tot)
     associate (p_onshell => pcm_instance%real_kinematics%p_born_onshell%phs_point(1)%p)
        call threshold_projection_born (mtop, L_to_cms, p_tot, p_onshell)
        if (debug2_active (D_THRESHOLD)) then
           print *, 'On-shell projected Born: '
           call vector4_write_set (p_onshell)
        end if
     end associate
   end subroutine kinematics_threshold_projection
 
 @ %def kinematics_threshold_projection
 @
 <<Kinematics: kinematics: TBP>>=
   procedure :: evaluate_radiation => kinematics_evaluate_radiation
 <<Kinematics: procedures>>=
   subroutine kinematics_evaluate_radiation (k, p_in, p_out, success)
     class(kinematics_t), intent(inout) :: k
     type(vector4_t), intent(in), dimension(:) :: p_in
     type(vector4_t), intent(out), dimension(:), allocatable :: p_out
     logical, intent(out) :: success
     type(vector4_t), dimension(:), allocatable :: p_real
     type(vector4_t), dimension(:), allocatable :: p_born
     real(default) :: xi_max_offshell, xi_offshell, y_offshell, jac_rand_dummy, phi
     select type (phs => k%phs)
     type is (phs_fks_t)
        allocate (p_born (size (p_in)))
        if (k%threshold) then
           p_born = phs%get_onshell_projected_momenta ()
        else
           p_born = p_in
        end if
        if (.not. k%phs%is_cm_frame () .and. .not. k%threshold) then
             p_born = inverse (k%phs%lt_cm_to_lab) * p_born
        end if
        call phs%compute_xi_max (p_born, k%threshold)
        if (k%emitter >= 0) then
           allocate (p_real (size (p_born) + 1))
           allocate (p_out (size (p_born) + 1))
           if (k%emitter <= k%n_in) then
              call phs%generate_isr (k%i_phs, p_real)
           else
              if (k%threshold) then
                 jac_rand_dummy = 1._default
                 call compute_y_from_emitter (phs%generator%real_kinematics%x_rad (I_Y), &
                      phs%generator%real_kinematics%p_born_cms%get_momenta(1), &
                      k%n_in, k%emitter, .false., phs%generator%y_max, jac_rand_dummy, &
                      y_offshell)
                 call phs%compute_xi_max (k%emitter, k%i_phs, y_offshell, &
                      phs%generator%real_kinematics%p_born_cms%get_momenta(1), &
                      xi_max_offshell)
                 xi_offshell = xi_max_offshell * phs%generator%real_kinematics%xi_tilde
                 phi = phs%generator%real_kinematics%phi
                 call phs%generate_fsr (k%emitter, k%i_phs, p_real, &
                      xi_y_phi = [xi_offshell, y_offshell, phi], no_jacobians = .true.)
                 call phs%generator%real_kinematics%p_real_cms%set_momenta (k%i_phs, p_real)
                 call phs%generate_fsr_threshold (k%emitter, k%i_phs, p_real)
                 if (debug2_active (D_SUBTRACTION)) &
                      call generate_fsr_threshold_for_other_emitters (k%emitter, k%i_phs)
              else if (k%i_con > 0) then
                 call phs%generate_fsr (k%emitter, k%i_phs, p_real, k%i_con)
              else
                 call phs%generate_fsr (k%emitter, k%i_phs, p_real)
              end if
           end if
           success = check_scalar_products (p_real)
           if (debug2_active (D_SUBTRACTION)) then
              call msg_debug2 (D_SUBTRACTION, "Real phase-space: ")
              call vector4_write_set (p_real)
           end if
           p_out = p_real
        else
           allocate (p_out (size (p_in))); p_out = p_in
           success = .true.
        end if
     end select
   contains
     subroutine generate_fsr_threshold_for_other_emitters (emitter, i_phs)
       integer, intent(in) :: emitter, i_phs
       integer :: ii_phs, this_emitter
       select type (phs => k%phs)
       type is (phs_fks_t)
          do ii_phs = 1, size (phs%phs_identifiers)
             this_emitter = phs%phs_identifiers(ii_phs)%emitter
             if (ii_phs /= i_phs .and. this_emitter /= emitter) &
                  call phs%generate_fsr_threshold (this_emitter, i_phs)
          end do
       end select
     end subroutine
   end subroutine kinematics_evaluate_radiation
 
 @ %def kinematics_evaluate_radiation
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Instances}
 
 <<[[instances.f90]]>>=
 <<File header>>
 
 module instances
 
 <<Use kinds>>
 <<Use strings>>
   use io_units
   use format_utils, only: write_separator
   use constants
   use diagnostics
   use os_interface
   use numeric_utils
   use lorentz
   use mci_base
   use particles
   use sm_qcd, only: qcd_t
   use interactions
   use quantum_numbers
   use model_data
   use helicities
   use flavors
   use beam_structures
   use variables
   use pdg_arrays, only: is_quark
   use sf_base
   use isr_collinear
   use physics_defs
   use process_constants
   use process_libraries
   use state_matrices
   use integration_results
   use phs_base
   use prc_core, only: prc_core_t, prc_core_state_t
 
   !!! We should depend less on these modules (move it to pcm_nlo_t e.g.)
   use phs_wood, only: phs_wood_t
   use phs_fks
   use blha_olp_interfaces, only: prc_blha_t
   use blha_config, only: BLHA_AMP_COLOR_C
   use prc_user_defined, only: prc_user_defined_base_t, user_defined_state_t
   use prc_threshold, only: prc_threshold_t
   use blha_olp_interfaces, only: blha_result_array_size
   use prc_openloops, only: prc_openloops_t, openloops_state_t
   use blha_olp_interfaces, only: blha_color_c_fill_offdiag, blha_color_c_fill_diag
 
   use ttv_formfactors, only: m1s_to_mpole
   !!! local modules
   use parton_states
   use process_counter
   use pcm_base
   use pcm
   use core_manager
   use process_config
   use process_mci
   use process
   use kinematics
 
 <<Standard module head>>
 
 <<Instances: public>>
 
 <<Instances: types>>
 
 <<Instances: interfaces>>
 
 contains
 
 <<Instances: procedures>>
 
 end module instances
 @ %def instances
 @
 \subsection{Term instance}
 A [[term_instance_t]] object contains all data that describe a term.  Each
 process component consists of one or more distinct terms which may differ in
 kinematics, but whose squared transition matrices have to be added pointwise.
 
 The [[active]] flag is set when this term is connected to an active
 process component.  Inactive terms are skipped for kinematics and evaluation.
 
 The [[k_term]] object is the instance of the kinematics setup
 (structure-function chain, phase space, etc.) that applies
 specifically to this term.  In ordinary cases, it consists of straight
 pointers to the seed kinematics.
 
 The [[amp]] array stores the amplitude values when we get them from evaluating
 the associated matrix-element code.
 
 The [[int_hard]] interaction describes the elementary hard process.
 It receives the momenta and the amplitude entries for each sampling point.
 
 The [[isolated]] object holds the effective parton state for the
 elementary interaction.  The amplitude entries are
 computed from [[int_hard]].
 
 The [[connected]] evaluator set
 convolutes this scattering matrix with the beam (and possibly
 structure-function) density matrix.
 
 The [[checked]] flag is set once we have applied cuts on this term.
 The result of this is stored in the [[passed]] flag.  Once the term
 has passed cuts, we calculate the various scale and weight expressions.
 <<Instances: types>>=
   type :: term_instance_t
      type(process_term_t), pointer :: config => null ()
      logical :: active = .false.
      type(kinematics_t) :: k_term
      complex(default), dimension(:), allocatable :: amp
      type(interaction_t) :: int_hard
      type(isolated_state_t) :: isolated
      type(connected_state_t) :: connected
      class(prc_core_state_t), allocatable :: core_state
      logical :: checked = .false.
      logical :: passed = .false.
      real(default) :: scale = 0
      real(default) :: fac_scale = 0
      real(default) :: ren_scale = 0
      real(default), allocatable :: alpha_qcd_forced
      real(default) :: weight = 1
      type(vector4_t), dimension(:), allocatable :: p_seed
      type(vector4_t), dimension(:), allocatable :: p_hard
      class(pcm_instance_t), pointer :: pcm_instance => null ()
      integer :: nlo_type = BORN
      integer, dimension(:), allocatable :: same_kinematics
      type(qn_index_map_t) :: connected_qn_index
      type(qn_index_map_t) :: hard_qn_index
    contains
    <<Instances: term instance: TBP>>
   end type term_instance_t
 
 @ %def term_instance_t
 @
 <<Instances: term instance: TBP>>=
   procedure :: write => term_instance_write
 <<Instances: procedures>>=
   subroutine term_instance_write (term, unit, show_eff_state, testflag)
     class(term_instance_t), intent(in) :: term
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: show_eff_state
     logical, intent(in), optional :: testflag
     integer :: u
     logical :: state
     u = given_output_unit (unit)
     state = .true.;  if (present (show_eff_state))  state = show_eff_state
     if (term%active) then
        if (associated (term%config)) then
           write (u, "(1x,A,I0,A,I0,A)")  "Term #", term%config%i_term, &
                " (component #", term%config%i_component, ")"
        else
           write (u, "(1x,A)")  "Term [undefined]"
        end if
     else
        write (u, "(1x,A,I0,A)")  "Term #", term%config%i_term, &
             " [inactive]"
     end if
     if (term%checked) then
        write (u, "(3x,A,L1)")      "passed cuts           = ", term%passed
     end if
     if (term%passed) then
        write (u, "(3x,A,ES19.12)")  "overall scale         = ", term%scale
        write (u, "(3x,A,ES19.12)")  "factorization scale   = ", term%fac_scale
        write (u, "(3x,A,ES19.12)")  "renormalization scale = ", term%ren_scale
        if (allocated (term%alpha_qcd_forced)) then
           write (u, "(3x,A,ES19.12)")  "alpha(QCD) forced     = ", &
                term%alpha_qcd_forced
        end if
        write (u, "(3x,A,ES19.12)")  "reweighting factor    = ", term%weight
     end if
     call term%k_term%write (u)
     call write_separator (u)
     write (u, "(1x,A)")  "Amplitude (transition matrix of the &
          &hard interaction):"
     call write_separator (u)
     call term%int_hard%basic_write (u, testflag = testflag)
     if (state .and. term%isolated%has_trace) then
        call write_separator (u)
        write (u, "(1x,A)")  "Evaluators for the hard interaction:"
        call term%isolated%write (u, testflag = testflag)
     end if
     if (state .and. term%connected%has_trace) then
        call write_separator (u)
        write (u, "(1x,A)")  "Evaluators for the connected process:"
        call term%connected%write (u, testflag = testflag)
     end if
   end subroutine term_instance_write
 
 @ %def term_instance_write
 @ The interactions and evaluators must be finalized.
 <<Instances: term instance: TBP>>=
   procedure :: final => term_instance_final
 <<Instances: procedures>>=
   subroutine term_instance_final (term)
     class(term_instance_t), intent(inout) :: term
     if (allocated (term%amp)) deallocate (term%amp)
     if (allocated (term%core_state)) deallocate (term%core_state)
     if (allocated (term%alpha_qcd_forced)) &
        deallocate (term%alpha_qcd_forced)
     if (allocated (term%p_seed)) deallocate(term%p_seed)
     if (allocated (term%p_hard)) deallocate (term%p_hard)
     call term%k_term%final ()
     call term%connected%final ()
     call term%isolated%final ()
     call term%int_hard%final ()
     term%pcm_instance => null ()
   end subroutine term_instance_final
 
 @ %def term_instance_final
 @ For initialization, we make use of defined assignment for the
 [[interaction_t]] type.  This creates a deep copy.
 
 The hard interaction (incoming momenta) is linked to the structure
 function instance.  In the isolated state, we either set pointers to
 both, or we create modified copies ([[rearrange]]) as effective
 structure-function chain and interaction, respectively.
 
 Finally, we set up the [[subevt]] component that will be used for
 evaluating observables, collecting particles from the trace evaluator
 in the effective connected state.  Their quantum numbers must be
 determined by following back source links and set explicitly, since
 they are already eliminated in that trace.
 
 The [[rearrange]] parts are still commented out; they could become
 relevant for a NLO algorithm.
 <<Instances: term instance: TBP>>=
   procedure :: init => term_instance_init
 <<Instances: procedures>>=
   subroutine term_instance_init (term, process, i_term, real_finite)
     class(term_instance_t), intent(inout), target :: term
     type(process_t), intent(in), target:: process
     integer, intent(in) :: i_term
     logical, intent(in), optional :: real_finite
     class(prc_core_t), pointer :: core => null ()
     type(process_beam_config_t) :: beam_config
     type(interaction_t), pointer :: sf_chain_int
     type(interaction_t), pointer :: src_int
     type(quantum_numbers_mask_t), dimension(:), allocatable :: mask_in
     type(state_matrix_t), pointer :: state_matrix
     type(flavor_t), dimension(:), allocatable :: flv_int, flv_src, f_in, f_out
     integer :: n_in, n_vir, n_out, n_tot, n_sub
     integer :: i, j
     logical :: me_already_squared, keep_fs_flavors
     logical :: decrease_n_tot
     logical :: requires_extended_sf
 
     me_already_squared = .false.
     keep_fs_flavors = .false.
 
     term%config => process%get_term_ptr (i_term)
     term%int_hard = term%config%int
     core => process%get_core_term (i_term)
     call core%allocate_workspace (term%core_state)
     select type (core)
     class is (prc_user_defined_base_t)
        call reduce_interaction (term%int_hard, &
             core%includes_polarization (), .true., .false.)
        me_already_squared = .true.
        allocate (term%amp (term%int_hard%get_n_matrix_elements ()))
     class default
        allocate (term%amp (term%config%n_allowed))
     end select
     if (allocated (term%core_state)) then
        select type (core_state => term%core_state)
        type is (openloops_state_t)
           call core_state%init_threshold (process%get_model_ptr ())
        end select
     end if
     term%amp = cmplx (0, 0, default)
     decrease_n_tot = term%nlo_type == NLO_REAL .and. &
          term%config%i_term_global /= term%config%i_sub
     if (present (real_finite)) then
        if (real_finite) decrease_n_tot = .false.
     end if
     if (decrease_n_tot) then
        allocate (term%p_seed (term%int_hard%get_n_tot () - 1))
     else
        allocate (term%p_seed (term%int_hard%get_n_tot ()))
     end if
     allocate (term%p_hard (term%int_hard%get_n_tot ()))
     sf_chain_int => term%k_term%sf_chain%get_out_int_ptr ()
     n_in = term%int_hard%get_n_in ()
     do j = 1, n_in
        i = term%k_term%sf_chain%get_out_i (j)
        call term%int_hard%set_source_link (j, sf_chain_int, i)
     end do
     call term%isolated%init (term%k_term%sf_chain, term%int_hard)
     allocate (mask_in (n_in))
     mask_in = term%k_term%sf_chain%get_out_mask ()
     select type (phs => term%k_term%phs)
       type is (phs_wood_t)
          if (me_already_squared) then
             call term%isolated%setup_identity_trace (core, mask_in, .true., .false.)
          else
             call term%isolated%setup_square_trace (core, mask_in, term%config%col, .false.)
          end if
       type is (phs_fks_t)
          select case (phs%mode)
          case (PHS_MODE_ADDITIONAL_PARTICLE)
             if (me_already_squared) then
                call term%isolated%setup_identity_trace (core, mask_in, .true., .false.)
             else
                keep_fs_flavors = term%config%data%n_flv > 1
                call term%isolated%setup_square_trace (core, mask_in, term%config%col, &
                     keep_fs_flavors)
             end if
          case (PHS_MODE_COLLINEAR_REMNANT)
             if (me_already_squared) then
                call term%isolated%setup_identity_trace (core, mask_in, .true., .false.)
             else
                call term%isolated%setup_square_trace (core, mask_in, term%config%col, .false.)
             end if
          end select
       class default
          call term%isolated%setup_square_trace (core, mask_in, term%config%col, .false.)
     end select
     if (term%nlo_type == NLO_VIRTUAL .or. (term%nlo_type == NLO_REAL .and. &
          term%config%i_term_global == term%config%i_sub) .or. &
          term%nlo_type == NLO_MISMATCH) then
        n_sub = term%get_n_sub ()
     else if (term%nlo_type == NLO_DGLAP) then
        n_sub = n_beam_structure_int
     else
        !!! No integration of real subtraction in interactions yet
        n_sub = 0
     end if
     keep_fs_flavors = keep_fs_flavors .or. me_already_squared
     requires_extended_sf = term%nlo_type == NLO_DGLAP .or. &
          (term%is_subtraction () .and. process%pcm_contains_pdfs ())
     call term%connected%setup_connected_trace (term%isolated, &
          undo_helicities = undo_helicities (core, me_already_squared), &
          keep_fs_flavors = keep_fs_flavors, &
          extended_sf = requires_extended_sf)
     associate (int_eff => term%isolated%int_eff)
       state_matrix => int_eff%get_state_matrix_ptr ()
       n_tot = int_eff%get_n_tot  ()
       flv_int = quantum_numbers_get_flavor &
            (state_matrix%get_quantum_number (1))
       allocate (f_in (n_in))
       f_in = flv_int(1:n_in)
       deallocate (flv_int)
     end associate
     n_in = term%connected%trace%get_n_in ()
     n_vir = term%connected%trace%get_n_vir ()
     n_out = term%connected%trace%get_n_out ()
     allocate (f_out (n_out))
     do j = 1, n_out
        call term%connected%trace%find_source &
             (n_in + n_vir + j, src_int, i)
        if (associated (src_int)) then
           state_matrix => src_int%get_state_matrix_ptr ()
           flv_src = quantum_numbers_get_flavor &
                (state_matrix%get_quantum_number (1))
           f_out(j) = flv_src(i)
           deallocate (flv_src)
        end if
     end do
 
     beam_config = process%get_beam_config ()
 
     call term%connected%setup_subevt (term%isolated%sf_chain_eff, &
          beam_config%data%flv, f_in, f_out)
     call term%connected%setup_var_list &
          (process%get_var_list_ptr (), beam_config%data)
 
     select type (core)
     class is (prc_user_defined_base_t)
        select type (pcm_instance => term%pcm_instance)
        type is (pcm_instance_nlo_t)
           associate (is_born => .not. (term%nlo_type == NLO_REAL .and. .not. term%is_subtraction ()))
             ! Does connected%trace never have any helicity qn?
             call setup_qn_index (term%connected_qn_index, term%connected%trace, pcm_instance, &
                  n_sub = n_sub, is_born = is_born, is_polarized = .false.)
             call setup_qn_index (term%hard_qn_index, term%int_hard, pcm_instance, &
                  n_sub = n_sub, is_born = is_born, is_polarized = core%includes_polarization ())
           end associate
        class default
           call term%connected_qn_index%init (term%connected%trace)
 	  call term%hard_qn_index%init (term%int_hard)
        end select
     class default
        call term%connected_qn_index%init (term%connected%trace)
        call term%hard_qn_index%init (term%int_hard)
     end select
   contains
 
    function undo_helicities (core, me_squared) result (val)
      logical :: val
      class(prc_core_t), intent(in) :: core
      logical, intent(in) :: me_squared
      select type (core)
      class is (prc_user_defined_base_t)
         val = me_squared .and. .not. core%includes_polarization ()
      class default
         val = .false.
      end select
    end function undo_helicities
 
    subroutine reduce_interaction (int, polarized_beams, keep_fs_flavors, &
       keep_colors)
      type(interaction_t), intent(inout) :: int
      logical, intent(in) :: polarized_beams
      logical, intent(in) :: keep_fs_flavors, keep_colors
      type(quantum_numbers_mask_t), dimension(:), allocatable :: qn_mask
      logical, dimension(:), allocatable :: mask_f, mask_c, mask_h
      integer :: n_tot, n_in
      n_in = int%get_n_in (); n_tot = int%get_n_tot ()
      allocate (qn_mask (n_tot))
      allocate (mask_f (n_tot), mask_c (n_tot), mask_h (n_tot))
      mask_c = .not. keep_colors
      mask_f (1 : n_in) = .false.
      if (keep_fs_flavors) then
         mask_f (n_in + 1 : ) = .false.
      else
         mask_f (n_in + 1 : ) = .true.
      end if
      if (polarized_beams) then
         mask_h (1 : n_in) = .false.
      else
         mask_h (1 : n_in) = .true.
      end if
      mask_h (n_in + 1 : ) = .true.
      call qn_mask%init (mask_f, mask_c, mask_h)
      call int%reduce_state_matrix (qn_mask, keep_order = .true.)
    end subroutine
 
 <<Instances: term instance init: procedures>>
   end subroutine term_instance_init
 
 @ %def term_instance_init
 @ Setup index mapping from state matrix to index pair [[i_flv]], [[i_sub]].
 <<Instances: term instance init: procedures>>=
   subroutine setup_qn_index (qn_index, int, pcm_instance, n_sub, is_born, is_polarized)
     type(qn_index_map_t), intent(out) :: qn_index
     class(interaction_t), intent(in) :: int
     class(pcm_instance_t), intent(in) :: pcm_instance
     integer, intent(in) :: n_sub
     logical, intent(in) :: is_born
     logical, intent(in) :: is_polarized
     integer :: i
     type(quantum_numbers_t), dimension(:, :), allocatable :: qn_config
     type(quantum_numbers_t), dimension(:, :), allocatable :: qn_hel
     select type (config => pcm_instance%config)
     type is (pcm_nlo_t)
        qn_config = config%get_qn (is_born)
     end select
     if (is_polarized) then
        ! term%config%data from higher scope
        call setup_qn_hel (int, term%config%data, qn_hel)
        call qn_index%init (int, qn_config, n_sub, qn_hel)
        call qn_index%set_helicity_flip (.true.)
     else
        call qn_index%init (int, qn_config, n_sub)
     end if
   end subroutine setup_qn_index
 
 @ %def setup_qn_index
 @ Setup beam polarisation quantum numbers, iff beam polarisation is required.
 
 We retrieve the full helicity information from [[term%config%data]] and reduce
 the information only to the inital state. Afterwards, we uniquify the initial
 state polarization by a applying a index (hash) table.
 
 The helicity information is fed into an array of quantum numbers to assign
 flavor, helicity and subtraction indices correctly to their matrix element.
 <<Instances: term instance init: procedures>>=
    subroutine setup_qn_hel (int, data, qn_hel)
      class(interaction_t), intent(in) :: int
      class(process_constants_t), intent(in) :: data
      type(quantum_numbers_t), dimension(:, :), allocatable, intent(out) :: qn_hel
      type(helicity_t), dimension(:), allocatable :: hel
      integer, dimension(:), allocatable :: index_table
      integer, dimension(:, :), allocatable :: hel_state
      integer :: i, j, n_hel_unique
      associate (n_in => int%get_n_in (), n_tot => int%get_n_tot ())
        allocate (hel_state (n_tot, data%get_n_hel ()), &
             source = data%hel_state)
        allocate (index_table (data%get_n_hel ()), &
             source = 0)
        forall (j=1:data%get_n_hel (), i=n_in+1:n_tot) hel_state(i, j) = 0
        n_hel_unique = 0
        HELICITY: do i = 1, data%get_n_hel ()
           do j = 1, data%get_n_hel ()
              if (index_table (j) == 0) then
                 index_table(j) = i; n_hel_unique = n_hel_unique + 1
                 cycle HELICITY
              else if (all (hel_state(:, i) == &
                   hel_state(:, index_table(j)))) then
                 cycle HELICITY
              end if
           end do
        end do HELICITY
        allocate (qn_hel (n_tot, n_hel_unique))
        allocate (hel (n_tot))
        do j = 1, n_hel_unique
           call hel%init (hel_state(:, index_table(j)))
           call qn_hel(:, j)%init (hel)
        end do
      end associate
    end subroutine setup_qn_hel
 
 @ %def setup_qn_hel
 @
 <<Instances: term instance: TBP>>=
   procedure :: init_from_process => term_instance_init_from_process
 <<Instances: procedures>>=
   subroutine term_instance_init_from_process (term_instance, &
          process, i, pcm_instance, sf_chain)
     class(term_instance_t), intent(inout), target :: term_instance
     type(process_t), intent(in), target :: process
     integer, intent(in) :: i
     class(pcm_instance_t), intent(in), target :: pcm_instance
     type(sf_chain_t), intent(in), target :: sf_chain
     type(process_term_t) :: term
     integer :: i_component
     logical :: requires_extended_sf
     term = process%get_term_ptr (i)
     i_component = term%i_component
     if (i_component /= 0) then
        term_instance%pcm_instance => pcm_instance
        term_instance%nlo_type = process%get_nlo_type_component (i_component)
        requires_extended_sf = term_instance%nlo_type == NLO_DGLAP .or. &
               (term_instance%nlo_type == NLO_REAL .and. process%get_i_sub (i) == i)
        call term_instance%setup_kinematics (sf_chain, &
             process%get_beam_config_ptr (), &
             process%get_phs_config (i_component), &
             requires_extended_sf)
        call term_instance%init (process, i, &
             real_finite = process%component_is_real_finite (i_component))
        select type (phs => term_instance%k_term%phs)
        type is (phs_fks_t)
           call term_instance%set_emitter (process%get_pcm_ptr ())
           call term_instance%setup_fks_kinematics (process%get_var_list_ptr (), &
                process%get_beam_config_ptr ())
        end select
        call term_instance%set_threshold (process%get_pcm_ptr ())
        call term_instance%setup_expressions (process%get_meta (), process%get_config ())
     end if
   end subroutine term_instance_init_from_process
 
 @ %def term_instance_init_from_process
 @ Initialize the seed-kinematics configuration.  All subobjects are
 allocated explicitly.
 <<Instances: term instance: TBP>>=
   procedure :: setup_kinematics => term_instance_setup_kinematics
 <<Instances: procedures>>=
   subroutine term_instance_setup_kinematics (term, sf_chain, &
      beam_config, phs_config, extended_sf)
     class(term_instance_t), intent(inout) :: term
     type(sf_chain_t), intent(in), target :: sf_chain
     type(process_beam_config_t), intent(in), target :: beam_config
     class(phs_config_t), intent(in), target :: phs_config
     logical, intent(in) :: extended_sf
     select type (config => term%pcm_instance%config)
     type is (pcm_nlo_t)
        call term%k_term%init_sf_chain (sf_chain, beam_config, &
             extended_sf = config%has_pdfs .and. extended_sf)
     class default
        call term%k_term%init_sf_chain (sf_chain, beam_config)
     end select
     !!! Add one for additional Born matrix element
     call term%k_term%init_phs (phs_config)
     call term%k_term%set_nlo_info (term%nlo_type)
     select type (phs => term%k_term%phs)
     type is (phs_fks_t)
        call phs%allocate_momenta (phs_config, &
             .not. (term%nlo_type == NLO_REAL))
        select type (config => term%pcm_instance%config)
        type is (pcm_nlo_t)
           call config%region_data%init_phs_identifiers (phs%phs_identifiers)
           !!! The triple select type pyramid of doom
           select type (pcm_instance => term%pcm_instance)
           type is (pcm_instance_nlo_t)
              if (allocated (pcm_instance%real_kinematics%alr_to_i_phs)) &
                   call config%region_data%set_alr_to_i_phs (phs%phs_identifiers, &
                        pcm_instance%real_kinematics%alr_to_i_phs)
           end select
        end select
     end select
   end subroutine term_instance_setup_kinematics
 
 @ %def term_instance_setup_kinematics
 @
 <<Instances: term instance: TBP>>=
   procedure :: setup_fks_kinematics => term_instance_setup_fks_kinematics
 <<Instances: procedures>>=
   subroutine term_instance_setup_fks_kinematics (term, var_list, beam_config)
     class(term_instance_t), intent(inout), target :: term
     type(var_list_t), intent(in) :: var_list
     type(process_beam_config_t), intent(in) :: beam_config
     integer :: mode
     logical :: singular_jacobian
     if (.not. (term%nlo_type == NLO_REAL .or. term%nlo_type == NLO_DGLAP .or. &
        term%nlo_type == NLO_MISMATCH)) return
     singular_jacobian = var_list%get_lval (var_str ("?powheg_use_singular_jacobian"))
     if (term%nlo_type == NLO_REAL) then
        mode = check_generator_mode (GEN_REAL_PHASE_SPACE)
     else if (term%nlo_type == NLO_MISMATCH) then
        mode = check_generator_mode (GEN_SOFT_MISMATCH)
     else
        mode = PHS_MODE_UNDEFINED
     end if
     select type (phs => term%k_term%phs)
     type is (phs_fks_t)
        select type (config => term%pcm_instance%config)
        type is (pcm_nlo_t)
           select type (pcm_instance => term%pcm_instance)
           type is (pcm_instance_nlo_t)
              call config%setup_phs_generator (pcm_instance, &
                   phs%generator, phs%config%sqrts, mode, singular_jacobian)
              if (beam_config%has_structure_function ()) then
                 pcm_instance%isr_kinematics%isr_mode = SQRTS_VAR
              else
                 pcm_instance%isr_kinematics%isr_mode = SQRTS_FIXED
              end if
              call msg_debug (D_PHASESPACE, "isr_mode: ", pcm_instance%isr_kinematics%isr_mode)
           end select
        end select
     class default
        call msg_fatal ("Phase space should be an FKS phase space!")
     end select
   contains
     function check_generator_mode (gen_mode_default) result (gen_mode)
        integer :: gen_mode
        integer, intent(in) :: gen_mode_default
        select type (config => term%pcm_instance%config)
        type is (pcm_nlo_t)
           associate (settings => config%settings)
              if (settings%test_coll_limit .and. settings%test_anti_coll_limit) &
                 call msg_fatal ("You cannot check the collinear and anti-collinear limit "&
                      &"at the same time!")
              if (settings%test_soft_limit .and. .not. settings%test_coll_limit &
                   .and. .not. settings%test_anti_coll_limit) then
                 gen_mode = GEN_SOFT_LIMIT_TEST
              else if (.not. settings%test_soft_limit .and. settings%test_coll_limit) then
                 gen_mode = GEN_COLL_LIMIT_TEST
              else if (.not. settings%test_soft_limit .and. settings%test_anti_coll_limit) then
                 gen_mode = GEN_ANTI_COLL_LIMIT_TEST
              else if (settings%test_soft_limit .and. settings%test_coll_limit) then
                 gen_mode = GEN_SOFT_COLL_LIMIT_TEST
              else if (settings%test_soft_limit .and. settings%test_anti_coll_limit) then
                 gen_mode = GEN_SOFT_ANTI_COLL_LIMIT_TEST
              else
                 gen_mode = gen_mode_default
              end if
           end associate
        end select
     end function check_generator_mode
   end subroutine term_instance_setup_fks_kinematics
 
 @ %def term_instance_setup_fks_kinematics
 @ Setup seed kinematics, starting from the MC parameter set given as
 argument.  As a result, the [[k_seed]] kinematics object is evaluated
 (except for the structure-function matrix-element evaluation, which we
 postpone until we know the factorization scale), and we have a valid
 [[p_seed]] momentum array.
 <<Instances: term instance: TBP>>=
   procedure :: compute_seed_kinematics => term_instance_compute_seed_kinematics
 <<Instances: procedures>>=
   subroutine term_instance_compute_seed_kinematics &
        (term, mci_work, phs_channel, success)
     class(term_instance_t), intent(inout), target :: term
     type(mci_work_t), intent(in) :: mci_work
     integer, intent(in) :: phs_channel
     logical, intent(out) :: success
     call term%k_term%compute_selected_channel &
          (mci_work, phs_channel, term%p_seed, success)
   end subroutine term_instance_compute_seed_kinematics
 
 @ %def term_instance_compute_seed_kinematics
 @
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_radiation_kinematics => term_instance_evaluate_radiation_kinematics
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_radiation_kinematics (term, x)
     class(term_instance_t), intent(inout) :: term
     real(default), dimension(:), intent(in) :: x
     select type (phs => term%k_term%phs)
     type is (phs_fks_t)
        if (phs%mode == PHS_MODE_ADDITIONAL_PARTICLE) &
              call term%k_term%evaluate_radiation_kinematics (x)
     end select
   end subroutine term_instance_evaluate_radiation_kinematics
 
 @ %def term_instance_evaluate_radiation_kinematics
 @
 <<Instances: term instance: TBP>>=
   procedure :: compute_xi_ref_momenta => term_instance_compute_xi_ref_momenta
 <<Instances: procedures>>=
   subroutine term_instance_compute_xi_ref_momenta (term)
     class(term_instance_t), intent(inout) :: term
     select type (pcm => term%pcm_instance%config)
     type is (pcm_nlo_t)
        call term%k_term%compute_xi_ref_momenta (pcm%region_data, term%nlo_type)
     end select
   end subroutine term_instance_compute_xi_ref_momenta
 
 @ %def term_instance_compute_xi_ref_momenta
 @
 <<Instances: term instance: TBP>>=
   procedure :: generate_fsr_in => term_instance_generate_fsr_in
 <<Instances: procedures>>=
   subroutine term_instance_generate_fsr_in (term)
     class(term_instance_t), intent(inout) :: term
     select type (phs => term%k_term%phs)
     type is (phs_fks_t)
        call phs%generate_fsr_in ()
     end select
   end subroutine term_instance_generate_fsr_in
 
 @ %def term_instance_generate_fsr_in
 @
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_projections => term_instance_evaluate_projections
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_projections (term)
     class(term_instance_t), intent(inout) :: term
     if (term%k_term%threshold .and. term%nlo_type > BORN) then
        if (debug2_active (D_THRESHOLD)) &
             print *, 'Evaluate on-shell projection: ', &
             char (component_status (term%nlo_type))
        select type (pcm_instance => term%pcm_instance)
        type is (pcm_instance_nlo_t)
           call term%k_term%threshold_projection (pcm_instance, term%nlo_type)
        end select
     end if
   end subroutine term_instance_evaluate_projections
 
 @ %def term_instance_evaluate_projections
 @
 <<Instances: term instance: TBP>>=
   procedure :: redo_sf_chain => term_instance_redo_sf_chain
 <<Instances: procedures>>=
   subroutine term_instance_redo_sf_chain (term, mci_work, phs_channel)
     class(term_instance_t), intent(inout) :: term
     type(mci_work_t), intent(in) :: mci_work
     integer, intent(in) :: phs_channel
     real(default), dimension(:), allocatable :: x
     integer :: sf_channel, n
     real(default) :: xi, y
     n = size (mci_work%get_x_strfun ())
     if (n > 0) then
        allocate (x(n))
        x = mci_work%get_x_strfun ()
        associate (k => term%k_term)
           sf_channel = k%phs%config%get_sf_channel (phs_channel)
           call k%sf_chain%compute_kinematics (sf_channel, x)
           deallocate (x)
        end associate
     end if
   end subroutine term_instance_redo_sf_chain
 
 @ %def term_instance_redo_sf_chain
 @ Inverse: recover missing parts of the kinematics, given a complete
 set of seed momenta.  Select a channel and reconstruct the MC parameter set.
 <<Instances: term instance: TBP>>=
   procedure :: recover_mcpar => term_instance_recover_mcpar
 <<Instances: procedures>>=
   subroutine term_instance_recover_mcpar (term, mci_work, phs_channel)
     class(term_instance_t), intent(inout), target :: term
     type(mci_work_t), intent(inout) :: mci_work
     integer, intent(in) :: phs_channel
     call term%k_term%recover_mcpar (mci_work, phs_channel, term%p_seed)
   end subroutine term_instance_recover_mcpar
 
 @ %def term_instance_recover_mcpar
 @ Part of [[recover_mcpar]], separately accessible.  Reconstruct all
 kinematics data in the structure-function chain instance.
 <<Instances: term instance: TBP>>=
   procedure :: recover_sfchain => term_instance_recover_sfchain
 <<Instances: procedures>>=
   subroutine term_instance_recover_sfchain (term, channel)
     class(term_instance_t), intent(inout), target :: term
     integer, intent(in) :: channel
     call term%k_term%recover_sfchain (channel, term%p_seed)
   end subroutine term_instance_recover_sfchain
 
 @ %def term_instance_recover_sfchain
 @ Compute the momenta in the hard interactions, one for each term that
 constitutes this process component.  In simple cases this amounts to
 just copying momenta.  In more advanced cases, we may generate
 distinct sets of momenta from the seed kinematics.
 
 The interactions in the term instances are accessed individually.  We may
 choose to calculate all terms at once together with the seed kinematics, use
 [[component%core_state]] for storage, and just fill the interactions here.
 <<Instances: term instance: TBP>>=
   procedure :: compute_hard_kinematics => &
        term_instance_compute_hard_kinematics
 <<Instances: procedures>>=
   subroutine term_instance_compute_hard_kinematics (term, skip_term, success)
     class(term_instance_t), intent(inout) :: term
     integer, intent(in), optional :: skip_term
     logical, intent(out) :: success
     type(vector4_t), dimension(:), allocatable :: p
     if (allocated (term%core_state)) &
        call term%core_state%reset_new_kinematics ()
     if (present (skip_term)) then
        if (term%config%i_term_global == skip_term) return
     end if
 
     if (term%nlo_type == NLO_REAL .and. term%k_term%emitter >= 0) then
        call term%k_term%evaluate_radiation (term%p_seed, p, success)
        select type (config => term%pcm_instance%config)
        type is (pcm_nlo_t)
           if (config%dalitz_plot%active) then
              if (term%k_term%emitter > term%k_term%n_in) then
                 if (p(term%k_term%emitter)**2 > tiny_07) &
                      call config%register_dalitz_plot (term%k_term%emitter, p)
              end if
           end if
        end select
     else if (is_subtraction_component (term%k_term%emitter, term%nlo_type)) then
        call term%k_term%modify_momenta_for_subtraction (term%p_seed, p)
        success = .true.
     else
        allocate (p (size (term%p_seed))); p = term%p_seed
        success = .true.
     end if
     call term%int_hard%set_momenta (p)
   end subroutine term_instance_compute_hard_kinematics
 
 @ %def term_instance_compute_hard_kinematics
 @ Here, we invert this.  We fetch the incoming momenta which reside
 in the appropriate [[sf_chain]] object, stored within the [[k_seed]]
 subobject.  On the other hand, we have the outgoing momenta of the
 effective interaction.  We rely on the process core to compute the
 remaining seed momenta and to fill the momenta within the hard
 interaction.  (The latter is trivial if hard and effective interaction
 coincide.)
 
 After this is done, the incoming momenta in the trace evaluator that
 corresponds to the hard (effective) interaction, are still
 left undefined.  We remedy this by calling [[receive_kinematics]] once.
 <<Instances: term instance: TBP>>=
   procedure :: recover_seed_kinematics => &
        term_instance_recover_seed_kinematics
 <<Instances: procedures>>=
   subroutine term_instance_recover_seed_kinematics (term)
     class(term_instance_t), intent(inout) :: term
     integer :: n_in
     n_in = term%k_term%n_in
     call term%k_term%get_incoming_momenta (term%p_seed(1:n_in))
     associate (int_eff => term%isolated%int_eff)
        call int_eff%set_momenta (term%p_seed(1:n_in), outgoing = .false.)
        term%p_seed(n_in + 1 : ) = int_eff%get_momenta (outgoing = .true.)
     end associate
     call term%isolated%receive_kinematics ()
   end subroutine term_instance_recover_seed_kinematics
 
 @ %def term_instance_recover_seed_kinematics
 @ Compute the integration parameters for all channels except the selected
 one.
 <<Instances: term instance: TBP>>=
   procedure :: compute_other_channels => &
        term_instance_compute_other_channels
 <<Instances: procedures>>=
   subroutine term_instance_compute_other_channels &
        (term, mci_work, phs_channel)
     class(term_instance_t), intent(inout), target :: term
     type(mci_work_t), intent(in) :: mci_work
     integer, intent(in) :: phs_channel
     call term%k_term%compute_other_channels (mci_work, phs_channel)
   end subroutine term_instance_compute_other_channels
 
 @ %def term_instance_compute_other_channels
 @ Recover beam momenta, i.e., return the beam momenta as currently
 stored in the kinematics subobject to their source.  This is a side effect.
 <<Instances: term instance: TBP>>=
   procedure :: return_beam_momenta => term_instance_return_beam_momenta
 <<Instances: procedures>>=
   subroutine term_instance_return_beam_momenta (term)
     class(term_instance_t), intent(in) :: term
     call term%k_term%return_beam_momenta ()
   end subroutine term_instance_return_beam_momenta
 
 @ %def term_instance_return_beam_momenta
 @
 <<Instances: term instance: TBP>>=
   procedure :: apply_real_partition => term_instance_apply_real_partition
 <<Instances: procedures>>=
   subroutine term_instance_apply_real_partition (term, process)
     class(term_instance_t), intent(inout) :: term
     type(process_t), intent(in) :: process
     real(default) :: f, sqme
     integer :: i_component
     integer :: i_amp, n_amps
     logical :: is_subtraction
     i_component = term%config%i_component
     if (process%component_is_selected (i_component) .and. &
            process%get_component_nlo_type (i_component) == NLO_REAL) then
        is_subtraction = process%get_component_type (i_component) == COMP_REAL_SING &
             .and. term%k_term%emitter < 0
        if (is_subtraction) return
        select type (pcm => process%get_pcm_ptr ())
        type is (pcm_nlo_t)
           f = pcm%real_partition%get_f (term%p_hard)
        end select
        n_amps = term%connected%trace%get_n_matrix_elements ()
        do i_amp = 1, n_amps
           sqme = real (term%connected%trace%get_matrix_element ( &
                term%connected_qn_index%get_index (i_amp, i_sub = 0)))
           call msg_debug2 (D_PROCESS_INTEGRATION, "term_instance_apply_real_partition")
           select type (pcm => term%pcm_instance%config)
           type is (pcm_nlo_t)
              select case (process%get_component_type (i_component))
              case (COMP_REAL_FIN, COMP_REAL_SING)
                 select case (process%get_component_type (i_component))
                 case (COMP_REAL_FIN)
                    call msg_debug2 (D_PROCESS_INTEGRATION, "Real finite")
                    sqme = sqme * (one - f)
                 case (COMP_REAL_SING)
                    call msg_debug2 (D_PROCESS_INTEGRATION, "Real singular")
                    sqme = sqme * f
                 end select
              end select
           end select
           call msg_debug2 (D_PROCESS_INTEGRATION, "apply_damping: sqme", sqme)
           call term%connected%trace%set_matrix_element (i_amp, cmplx (sqme, zero, default))
        end do
     end if
   end subroutine term_instance_apply_real_partition
 
 @ %def term_instance_apply_real_partition
 @
 <<Instances: term instance: TBP>>=
   procedure :: get_lorentz_transformation => term_instance_get_lorentz_transformation
 <<Instances: procedures>>=
   function term_instance_get_lorentz_transformation (term) result (lt)
     type(lorentz_transformation_t) :: lt
     class(term_instance_t), intent(in) :: term
     lt = term%k_term%phs%get_lorentz_transformation ()
   end function term_instance_get_lorentz_transformation
 
 @ %def term_instance_get_lorentz_transformation
 @
 <<Instances: term instance: TBP>>=
   procedure :: get_p_hard => term_instance_get_p_hard
 <<Instances: procedures>>=
   pure function term_instance_get_p_hard (term_instance) result (p_hard)
     type(vector4_t), dimension(:), allocatable :: p_hard
     class(term_instance_t), intent(in) :: term_instance
     allocate (p_hard (size (term_instance%p_hard)))
     p_hard = term_instance%p_hard
   end function term_instance_get_p_hard
 
 @ %def term_instance_get_p_hard
 @
 <<Instances: term instance: TBP>>=
   procedure :: set_emitter => term_instance_set_emitter
 <<Instances: procedures>>=
   subroutine term_instance_set_emitter (term, pcm)
     class(term_instance_t), intent(inout) :: term
     class(pcm_t), intent(in) :: pcm
     integer :: i_phs
     logical :: set_emitter
     select type (pcm)
     type is (pcm_nlo_t)
        !!! Without resonances, i_alr = i_phs
        i_phs = term%config%i_term
        term%k_term%i_phs = term%config%i_term
        select type (phs => term%k_term%phs)
        type is (phs_fks_t)
           set_emitter = i_phs <= pcm%region_data%n_phs .and. term%nlo_type == NLO_REAL
           if (set_emitter) then
              term%k_term%emitter = phs%phs_identifiers(i_phs)%emitter
              select type (pcm => term%pcm_instance%config)
              type is (pcm_nlo_t)
                 if (allocated (pcm%region_data%i_phs_to_i_con)) &
                    term%k_term%i_con = pcm%region_data%i_phs_to_i_con (i_phs)
              end select
           end if
        end select
     end select
   end subroutine term_instance_set_emitter
 
 @ %def term_instance_set_emitter
 @
 <<Instances: term instance: TBP>>=
   procedure :: set_threshold => term_instance_set_threshold
 <<Instances: procedures>>=
   subroutine term_instance_set_threshold (term, pcm)
     class(term_instance_t), intent(inout) :: term
     class(pcm_t), intent(in) :: pcm
     select type (pcm)
     type is (pcm_nlo_t)
        term%k_term%threshold = pcm%settings%factorization_mode == FACTORIZATION_THRESHOLD
     class default
        term%k_term%threshold = .false.
     end select
   end subroutine term_instance_set_threshold
 
 @ %def term_instance_set_threshold
 @ For initializing the expressions, we need the local variable list and the
 parse trees.
 <<Instances: term instance: TBP>>=
   procedure :: setup_expressions => term_instance_setup_expressions
 <<Instances: procedures>>=
   subroutine term_instance_setup_expressions (term, meta, config)
     class(term_instance_t), intent(inout), target :: term
     type(process_metadata_t), intent(in), target :: meta
     type(process_config_data_t), intent(in) :: config
     if (allocated (config%ef_cuts)) &
          call term%connected%setup_cuts (config%ef_cuts)
     if (allocated (config%ef_scale)) &
          call term%connected%setup_scale (config%ef_scale)
     if (allocated (config%ef_fac_scale)) &
          call term%connected%setup_fac_scale (config%ef_fac_scale)
     if (allocated (config%ef_ren_scale)) &
          call term%connected%setup_ren_scale (config%ef_ren_scale)
     if (allocated (config%ef_weight)) &
          call term%connected%setup_weight (config%ef_weight)
   end subroutine term_instance_setup_expressions
 
 @ %def term_instance_setup_expressions
 @ Prepare the extra evaluators that we need for processing events.
 
 The quantum numbers mask of the incoming particle
 <<Instances: term instance: TBP>>=
   procedure :: setup_event_data => term_instance_setup_event_data
 <<Instances: procedures>>=
   subroutine term_instance_setup_event_data (term, core, model)
     class(term_instance_t), intent(inout), target :: term
     class(prc_core_t), intent(in) :: core
     class(model_data_t), intent(in), target :: model
     integer :: n_in
     type(quantum_numbers_mask_t), dimension(:), allocatable :: mask_in
     n_in = term%int_hard%get_n_in ()
     allocate (mask_in (n_in))
     mask_in = term%k_term%sf_chain%get_out_mask ()
     call setup_isolated (term%isolated, core, model, mask_in, term%config%col)
     call setup_connected (term%connected, term%isolated, term%nlo_type)
  contains
    subroutine setup_isolated (isolated, core, model, mask, color)
      type(isolated_state_t), intent(inout), target :: isolated
      class(prc_core_t), intent(in) :: core
      class(model_data_t), intent(in), target :: model
      type(quantum_numbers_mask_t), intent(in), dimension(:) :: mask
      integer, intent(in), dimension(:) :: color
      call isolated%setup_square_matrix (core, model, mask, color)
      call isolated%setup_square_flows (core, model, mask)
    end subroutine setup_isolated
 
    subroutine setup_connected (connected, isolated, nlo_type)
      type(connected_state_t), intent(inout), target :: connected
      type(isolated_state_t), intent(in), target :: isolated
      integer :: nlo_type
      type(quantum_numbers_mask_t), dimension(:), allocatable :: mask
      call connected%setup_connected_matrix (isolated)
      if (term%nlo_type == NLO_VIRTUAL .or. (term%nlo_type == NLO_REAL &
          .and. term%config%i_term_global == term%config%i_sub) &
          .or. term%nlo_type == NLO_DGLAP) then
         !!! We don't care about the subtraction matrix elements in
         !!! connected%matrix, because all entries there are supposed
         !!! to be squared. To be able to match with flavor quantum numbers,
         !!! we remove the subtraction quantum entries from the state matrix.
         allocate (mask (connected%matrix%get_n_tot()))
         call mask%set_sub (1)
         call connected%matrix%reduce_state_matrix (mask, keep_order = .true.)
      end if
      call connected%setup_connected_flows (isolated)
      call connected%setup_state_flv (isolated%get_n_out ())
    end subroutine setup_connected
  end subroutine term_instance_setup_event_data
 
 @ %def term_instance_setup_event_data
 @ Color-correlated matrix elements should be obtained from
 the external BLHA provider. According to the standard, the
 matrix elements output is a one-dimensional array. For FKS
 subtraction, we require the  matrix $B_{ij}$. BLHA prescribes
 a mapping $(i, j) \to k$, where $k$ is the index of the matrix
 element in the output array. It focusses on the off-diagonal entries,
 i.e. $i \neq j$. The subroutine [[blha_color_c_fill_offdiag]] realizes
 this mapping. The diagonal entries can simply be obtained as
 the product of the Born matrix element and either $C_A$ or $C_F$,
 which is achieved by [[blha_color_c_fill_diag]].
 For simple processes, i.e. those with only one color line, it is
 $B_{ij} = C_F \cdot B$. For those, we keep the possibility of computing
 color correlations by a multiplication of the Born matrix element with $C_F$.
 It is triggered by the [[use_internal_color_correlations]] flag and should
 be used only for testing purposes. However, it is also used for
 the threshold computation where the process is well-defined and fixed.
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_color_correlations => &
      term_instance_evaluate_color_correlations
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_color_correlations (term, core)
     class(term_instance_t), intent(inout) :: term
     class(prc_core_t), intent(inout) :: core
     integer :: i_flv_born
     select type (pcm_instance => term%pcm_instance)
     type is (pcm_instance_nlo_t)
        select type (config => pcm_instance%config)
        type is (pcm_nlo_t)
           call msg_debug2 (D_SUBTRACTION, &
                "term_instance_evaluate_color_correlations: " // &
                "use_internal_color_correlations:", &
                config%settings%use_internal_color_correlations)
           call msg_debug2 (D_SUBTRACTION, "fac_scale", term%fac_scale)
 
           do i_flv_born = 1, config%region_data%n_flv_born
              select case (term%nlo_type)
              case (NLO_REAL)
                 call transfer_me_array_to_bij (config, i_flv_born, &
                      pcm_instance%real_sub%sqme_born (i_flv_born), &
                      pcm_instance%real_sub%sqme_born_color_c (:, :, i_flv_born))
              case (NLO_MISMATCH)
                 call transfer_me_array_to_bij (config, i_flv_born, &
                      pcm_instance%soft_mismatch%sqme_born (i_flv_born), &
                      pcm_instance%soft_mismatch%sqme_born_color_c (:, :, i_flv_born))
              case (NLO_VIRTUAL)
                 !!! This is just a copy of the above with a different offset and can for sure be unified
                 call transfer_me_array_to_bij (config, i_flv_born, &
                      -one, pcm_instance%virtual%sqme_color_c (:, :, i_flv_born))
              end select
           end do
        end select
     end select
   contains
     function get_trivial_cf_factors (n_tot, flv, factorization_mode) result (beta_ij)
       integer, intent(in) :: n_tot, factorization_mode
       integer, intent(in), dimension(:) :: flv
       real(default), dimension(n_tot, n_tot) :: beta_ij
       if (factorization_mode == NO_FACTORIZATION) then
          beta_ij = get_trivial_cf_factors_default (n_tot, flv)
       else
          beta_ij = get_trivial_cf_factors_threshold (n_tot, flv)
       end if
     end function get_trivial_cf_factors
 
     function get_trivial_cf_factors_default (n_tot, flv) result (beta_ij)
       integer, intent(in) :: n_tot
       integer, intent(in), dimension(:) :: flv
       real(default), dimension(n_tot, n_tot) :: beta_ij
       integer :: i, j
       beta_ij = zero
       if (count (is_quark (flv)) == 2) then
          do i = 1, n_tot
             do j = 1, n_tot
                if (is_quark(flv(i)) .and. is_quark(flv(j))) then
                   if (i == j) then
                      beta_ij(i,j)= -cf
                   else
                      beta_ij(i,j) = cf
                   end if
                end if
             end do
          end do
       end if
     end function get_trivial_cf_factors_default
 
     function get_trivial_cf_factors_threshold (n_tot, flv) result (beta_ij)
       integer, intent(in) :: n_tot
       integer, intent(in), dimension(:) :: flv
       real(default), dimension(n_tot, n_tot) :: beta_ij
       integer :: i
       beta_ij = zero
       do i = 1, 4
          beta_ij(i,i) = -cf
       end do
       beta_ij(1,2) = cf; beta_ij(2,1) = cf
       beta_ij(3,4) = cf; beta_ij(4,3) = cf
     end function get_trivial_cf_factors_threshold
 
     subroutine transfer_me_array_to_bij (pcm, i_flv, &
          sqme_born, sqme_color_c)
       type(pcm_nlo_t), intent(in) :: pcm
       integer, intent(in) :: i_flv
       real(default), intent(in) :: sqme_born
       real(default), dimension(:,:), intent(inout) :: sqme_color_c
       integer :: i_color_c, i_sub, n_pdf_off, virt_off, n_offset
       real(default), dimension(:), allocatable :: sqme
       call msg_debug2 (D_PROCESS_INTEGRATION, "transfer_me_array_to_bij")
       if (pcm%settings%use_internal_color_correlations) then
          !!! A negative value for sqme_born indicates that the Born matrix
          !!! element is multiplied at a different place, e.g. in the case
          !!! of the virtual component
          sqme_color_c = get_trivial_cf_factors &
               (pcm%region_data%get_n_legs_born (), &
               pcm%region_data%get_flv_states_born (i_flv), &
               pcm%settings%factorization_mode)
          if (sqme_born > zero) then
             sqme_color_c = sqme_born * sqme_color_c
          else if (sqme_born == zero) then
             sqme_color_c = zero
          end if
       else
          n_offset = 0
          if (term%nlo_type == NLO_VIRTUAL) then
             n_offset = 1
          else if (pcm%has_pdfs .and. term%is_subtraction ()) then
             n_offset = n_beam_structure_int
          end if
          allocate (sqme (term%get_n_sub_color ()), source = zero)
          do i_sub = 1, term%get_n_sub_color ()
             sqme(i_sub) = real(term%connected%trace%get_matrix_element ( &
                  term%connected_qn_index%get_index (i_flv, i_sub = i_sub + n_offset)), default)
          end do
          call blha_color_c_fill_offdiag (pcm%region_data%n_legs_born, &
               sqme, sqme_color_c)
          call blha_color_c_fill_diag (real(term%connected%trace%get_matrix_element ( &
               term%connected_qn_index%get_index (i_flv, i_sub = 0)), default), &
               pcm%region_data%get_flv_states_born (i_flv), &
               sqme_color_c)
       end if
     end subroutine transfer_me_array_to_bij
   end subroutine term_instance_evaluate_color_correlations
 
 @ %def term_instance_evaluate_color_correlations
 @
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_charge_correlations => &
      term_instance_evaluate_charge_correlations
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_charge_correlations (term, core)
     class(term_instance_t), intent(inout) :: term
     class(prc_core_t), intent(inout) :: core
     integer :: i_flv_born
     select type (pcm_instance => term%pcm_instance)
     type is (pcm_instance_nlo_t)
        select type (config => pcm_instance%config)
        type is (pcm_nlo_t)
           do i_flv_born = 1, config%region_data%n_flv_born
              select case (term%nlo_type)
              case (NLO_REAL)
                 call transfer_me_array_to_bij (config, i_flv_born, &
                      pcm_instance%real_sub%sqme_born (i_flv_born), &
                      pcm_instance%real_sub%sqme_born_charge_c (:, :, i_flv_born))
              case (NLO_MISMATCH)
                 call transfer_me_array_to_bij (config, i_flv_born, &
                      pcm_instance%soft_mismatch%sqme_born (i_flv_born), &
                      pcm_instance%soft_mismatch%sqme_born_charge_c (:, :, i_flv_born))
              case (NLO_VIRTUAL)
                 call transfer_me_array_to_bij (config, i_flv_born, &
                      -one, pcm_instance%virtual%sqme_charge_c (:, :, i_flv_born))
              end select
           end do
        end select
     end select
   contains
     subroutine transfer_me_array_to_bij (pcm, i_flv, sqme_born, sqme_charge_c)
       type(pcm_nlo_t), intent(in) :: pcm
       integer, intent(in) :: i_flv
       real(default), intent(in) :: sqme_born
       real(default), dimension(:,:), intent(inout) :: sqme_charge_c
       integer :: n_legs_born, i, j
       integer, dimension(:), allocatable :: sigma
       real(default), dimension(:), allocatable :: Q
       n_legs_born = pcm%region_data%n_legs_born
       associate (flv_born => pcm%region_data%flv_born(i_flv))
          allocate (sigma (n_legs_born), Q (size (flv_born%charge)))
          Q = flv_born%charge
          sigma(1:flv_born%n_in) = sign (1, flv_born%flst(1:flv_born%n_in))
          sigma(flv_born%n_in + 1: ) = -sign (1, flv_born%flst(flv_born%n_in + 1: ))
       end associate
       do i = 1, n_legs_born
          do j = 1, n_legs_born
             sqme_charge_c(i, j) = sigma(i) * sigma(j) * Q(i) * Q(j) * (-one)
          end do
       end do
       sqme_charge_c = sqme_charge_c * sqme_born
     end subroutine transfer_me_array_to_bij
   end subroutine term_instance_evaluate_charge_correlations
 
 @ %def term_instance_evaluate_charge_correlations
 @ The information about spin correlations is not stored in the [[nlo_settings]] because
 it is only available after the [[fks_regions]] have been created.
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_spin_correlations => term_instance_evaluate_spin_correlations
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_spin_correlations (term, core)
     class(term_instance_t), intent(inout) :: term
     class(prc_core_t), intent(inout) :: core
     integer :: i_flv, i_hel, i_sub, i_emitter, emitter
     integer :: n_flv, n_sub_color, n_sub_spin, n_offset
     real(default), dimension(0:3, 0:3) :: sqme_spin_c
     real(default), dimension(:), allocatable :: sqme_spin_c_all
     real(default), dimension(:), allocatable :: sqme_spin_c_arr
     call msg_debug2 (D_PROCESS_INTEGRATION, &
          "term_instance_evaluate_spin_correlations")
     select type (pcm_instance => term%pcm_instance)
     type is (pcm_instance_nlo_t)
        if (pcm_instance%real_sub%requires_spin_correlations () &
             .and. term%nlo_type == NLO_REAL) then
           select type (core)
           type is (prc_openloops_t)
              select type (config => pcm_instance%config)
              type is (pcm_nlo_t)
                 n_flv = term%connected_qn_index%get_n_flv ()
                 n_sub_color = term%get_n_sub_color ()
                 n_sub_spin = term%get_n_sub_spin ()
                 n_offset = 0; if(config%has_pdfs) n_offset = n_beam_structure_int
                 allocate (sqme_spin_c_arr(16))
                 do i_flv = 1, n_flv
                    allocate (sqme_spin_c_all(n_sub_spin))
                    do i_sub = 1, n_sub_spin
                       sqme_spin_c_all(i_sub) = real(term%connected%trace%get_matrix_element &
                            (term%connected_qn_index%get_index (i_flv, &
                            i_sub = i_sub + n_offset + n_sub_color)), default)
                    end do
                    do i_emitter = 1, config%region_data%n_emitters
                       emitter = config%region_data%emitters(i_emitter)
                       if (emitter > 0) then
                          call split_array (sqme_spin_c_all, sqme_spin_c_arr)
                          sqme_spin_c = reshape (sqme_spin_c_arr, (/4,4/))
                          pcm_instance%real_sub%sqme_born_spin_c(:,:,emitter,i_flv) = sqme_spin_c
                       end if
                    end do
                    deallocate (sqme_spin_c_all)
                 end do
              end select
           class default
              call msg_fatal ("Spin correlations so far only supported by OpenLoops.")
           end select
        end if
     end select
   end subroutine term_instance_evaluate_spin_correlations
 
 @ %def term_instance_evaluate_spin_correlations
 @ Compute collinear ISR from interactions, real component and DLGAP remnant are
 handled accordingly.
 <<Instances: term instance: TBP>>=
   procedure :: compute_sqme_coll_isr => term_instance_compute_sqme_coll_isr
 <<Instances: procedures>>=
   subroutine term_instance_compute_sqme_coll_isr (term)
     class(term_instance_t), intent(in) :: term
     integer :: i_flv
     integer, parameter :: BEAM_PLUS = 1, BEAM_MINUS = 2, &
        PDF = 1, PDF_SINGLET = 2
     select type (pcm_instance => term%pcm_instance)
     type is (pcm_instance_nlo_t)
        select type (pcm => term%pcm_instance%config)
        type is (pcm_nlo_t)
           associate (me => term%connected%trace%get_matrix_element ())
              do i_flv = 1, pcm%region_data%n_flv_born
                 call set_sqme_coll_isr (BEAM_PLUS, PDF, i_flv, &
                      real(me(term%connected_qn_index%get_index (i_flv, i_sub = 1))))
                 call set_sqme_coll_isr (BEAM_MINUS, PDF, i_flv, &
                      real(me(term%connected_qn_index%get_index (i_flv, i_sub = 2))))
                 if (pcm%settings%nlo_correction_type == "QCD" .or. &
                      pcm%settings%nlo_correction_type == "Full") then
                    call set_sqme_coll_isr (BEAM_PLUS, PDF_SINGLET, i_flv, &
                         real(me(term%connected_qn_index%get_index (i_flv, i_sub = 3))))
                    call set_sqme_coll_isr (BEAM_MINUS, PDF_SINGLET, i_flv, &
                         real(me(term%connected_qn_index%get_index (i_flv, i_sub = 4))))
                 end if
              end do
           end associate
           if (debug2_active (D_BEAMS)) then
              call msg_debug2 (D_BEAMS, "term_instance_compute_sqme_coll_isr")
              if (term%nlo_type == NLO_REAL) then
                 print *, "nlo_type: REAL"
                 print *, "n_flv: ", pcm%region_data%n_flv_born
                 print *, "i_flv: ", i_flv
                 print *, "Beam 1: "
                 print *, " quarks: ", pcm_instance%real_sub%sqme_coll_isr (BEAM_PLUS, PDF, :)
                 print *, " gluon:  ", pcm_instance%real_sub%sqme_coll_isr (BEAM_PLUS, PDF_SINGLET, :)
                 print *, "Beam 2: "
                 print *, " quarks: ", pcm_instance%real_sub%sqme_coll_isr (BEAM_MINUS, PDF, :)
                 print *, " gluon:  ", pcm_instance%real_sub%sqme_coll_isr (BEAM_MINUS, PDF_SINGLET, :)
              else if (term%nlo_type == NLO_DGLAP) then
                 print *, "nlo_type: DGLAP"
                 print *, "n_flv: ", pcm%region_data%n_flv_born
                 print *, "i_flv: ", i_flv
                 print *, "Beam 1: "
                 print *, " quarks: ", pcm_instance%dglap_remnant%sqme_coll_isr (BEAM_PLUS, PDF, :)
                 print *, " gluon:  ", pcm_instance%dglap_remnant%sqme_coll_isr (BEAM_PLUS, PDF_SINGLET, :)
                 print *, "Beam 2: "
                 print *, " quarks: ", pcm_instance%dglap_remnant%sqme_coll_isr (BEAM_MINUS, PDF, :)
                 print *, " gluon:  ", pcm_instance%dglap_remnant%sqme_coll_isr (BEAM_MINUS, PDF_SINGLET, :)
              end if
           end if
        end select
     end select
   contains
     subroutine set_sqme_coll_isr (i_beam, i_type, i_flv, me)
       integer, intent(in) :: i_beam, i_type, i_flv
       real(default), intent(in) :: me
       select type (pcm_instance => term%pcm_instance)
       type is (pcm_instance_nlo_t)
          select case (term%nlo_type)
          case (NLO_REAL)
             pcm_instance%real_sub%sqme_coll_isr (i_beam, i_type, i_flv) = me
          case (NLO_DGLAP)
             pcm_instance%dglap_remnant%sqme_coll_isr (i_beam, i_type, i_flv) = me
          end select
       end select
     end subroutine set_sqme_coll_isr
   end subroutine term_instance_compute_sqme_coll_isr
 
 @ %def term_instance_compute_sqme_coll_isr
 @
 <<Instances: term instance: TBP>>=
   procedure :: apply_fks => term_instance_apply_fks
 <<Instances: procedures>>=
   subroutine term_instance_apply_fks (term, alpha_s_sub, alpha_qed_sub)
     class(term_instance_t), intent(inout) :: term
     real(default), intent(in) :: alpha_s_sub, alpha_qed_sub
     real(default), dimension(:), allocatable :: sqme
     integer :: i, i_phs, emitter
     logical :: is_subtraction
     select type (pcm_instance => term%pcm_instance)
     type is (pcm_instance_nlo_t)
        select type (config => pcm_instance%config)
        type is (pcm_nlo_t)
           if (term%connected%has_matrix) then
              allocate (sqme (config%get_n_alr ()))
           else
              allocate (sqme (1))
           end if
           sqme = zero
           select type (phs => term%k_term%phs)
           type is (phs_fks_t)
              call pcm_instance%set_real_and_isr_kinematics &
                   (phs%phs_identifiers, term%k_term%phs%get_sqrts ())
              if (term%k_term%emitter < 0) then
                 call pcm_instance%set_subtraction_event ()
                 do i_phs = 1, config%region_data%n_phs
                    emitter = phs%phs_identifiers(i_phs)%emitter
                    call pcm_instance%real_sub%compute (emitter, &
                         i_phs, alpha_s_sub, alpha_qed_sub, term%connected%has_matrix, sqme)
                 end do
              else
                 call pcm_instance%set_radiation_event ()
                 emitter = term%k_term%emitter; i_phs = term%k_term%i_phs
                 do i = 1, term%connected_qn_index%get_n_flv ()
                    pcm_instance%real_sub%sqme_real_non_sub (i, i_phs) = &
                      real (term%connected%trace%get_matrix_element ( &
                      term%connected_qn_index%get_index (i)))
                 end do
                 call pcm_instance%real_sub%compute (emitter, i_phs, alpha_s_sub, &
                      alpha_qed_sub, term%connected%has_matrix, sqme)
              end if
           end select
        end select
     end select
     if (term%connected%has_trace) &
          call term%connected%trace%set_only_matrix_element &
               (1, cmplx (sum(sqme), 0, default))
     select type (config => term%pcm_instance%config)
     type is (pcm_nlo_t)
        is_subtraction = term%k_term%emitter < 0
        if (term%connected%has_matrix) &
            call refill_evaluator (cmplx (sqme, 0, default), &
                 config%get_qn (is_subtraction), &
                 config%region_data%get_flavor_indices (is_subtraction), &
                 term%connected%matrix)
        if (term%connected%has_flows) &
             call refill_evaluator (cmplx (sqme, 0, default), &
                  config%get_qn (is_subtraction), &
                  config%region_data%get_flavor_indices (is_subtraction), &
                  term%connected%flows)
     end select
   end subroutine term_instance_apply_fks
 
 @ %def term_instance_apply_fks
 @
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_sqme_virt => term_instance_evaluate_sqme_virt
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_sqme_virt (term, alpha_s, alpha_qed)
      class(term_instance_t), intent(inout) :: term
      real(default), intent(in) :: alpha_s, alpha_qed
      real(default) :: alpha_coupling
      type(vector4_t), dimension(:), allocatable :: p_born
      real(default), dimension(:), allocatable :: sqme_virt
      integer :: i_flv
      if (term%nlo_type /= NLO_VIRTUAL) call msg_fatal &
         ("Trying to evaluate virtual matrix element with unsuited term_instance.")
      if (debug2_active (D_VIRTUAL)) then
         call msg_debug2 (D_VIRTUAL, "Evaluating virtual-subtracted matrix elements")
         print *, 'ren_scale: ', term%ren_scale
         print *, 'fac_scale: ', term%fac_scale
      end if
      select type (config => term%pcm_instance%config)
      type is (pcm_nlo_t)
         select type (pcm_instance => term%pcm_instance)
         type is (pcm_instance_nlo_t)
            associate (nlo_corr_type => config%region_data%regions(1)%nlo_correction_type)
               if (nlo_corr_type == "QCD") then
                  alpha_coupling = alpha_s
                  if (debug2_active (D_VIRTUAL)) print *, 'alpha_s: ', alpha_coupling
               else if (nlo_corr_type == "QED") then
                  alpha_coupling = alpha_qed
                  if (debug2_active (D_VIRTUAL)) print *, 'alpha_qed: ', alpha_coupling
               end if
            end associate
            allocate (p_born (config%region_data%n_legs_born))
            if (config%settings%factorization_mode == FACTORIZATION_THRESHOLD) then
               p_born = pcm_instance%real_kinematics%p_born_onshell%get_momenta(1)
            else
               p_born = term%int_hard%get_momenta ()
            end if
            call pcm_instance%set_momenta_and_scales_virtual &
                 (p_born, term%ren_scale, term%fac_scale)
            select type (pcm_instance => term%pcm_instance)
            type is (pcm_instance_nlo_t)
               associate (virtual => pcm_instance%virtual)
                 do i_flv = 1, term%connected_qn_index%get_n_flv ()
                    virtual%sqme_born(i_flv) = &
                         real (term%connected%trace%get_matrix_element ( &
                         term%connected_qn_index%get_index (i_flv, i_sub = 0)))
                    virtual%sqme_virt_fin(i_flv) = &
                         real (term%connected%trace%get_matrix_element ( &
                         term%connected_qn_index%get_index (i_flv, i_sub = 1)))
                 end do
               end associate
            end select
            call pcm_instance%compute_sqme_virt (term%p_hard, alpha_coupling, &
                 term%connected%has_matrix, sqme_virt)
            call term%connected%trace%set_only_matrix_element &
                 (1, cmplx (sum(sqme_virt) * term%weight, 0, default))
            if (term%connected%has_matrix) then
               call refill_evaluator (cmplx (sqme_virt * term%weight, 0, default), &
                    config%get_qn (.true.), &
                    config%region_data%get_flavor_indices (.true.), &
                    term%connected%matrix)
            end if
         end select
      end select
   end subroutine term_instance_evaluate_sqme_virt
 
 @ %def term_instance_evaluate_sqme_virt
 @
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_sqme_mismatch => term_instance_evaluate_sqme_mismatch
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_sqme_mismatch (term, alpha_s)
     class(term_instance_t), intent(inout) :: term
     real(default), intent(in) :: alpha_s
     real(default), dimension(:), allocatable :: sqme_mism
     if (term%nlo_type /= NLO_MISMATCH) call msg_fatal &
        ("Trying to evaluate soft mismatch with unsuited term_instance.")
     select type (pcm_instance => term%pcm_instance)
     type is (pcm_instance_nlo_t)
        call pcm_instance%compute_sqme_mismatch &
             (alpha_s, term%connected%has_matrix, sqme_mism)
     end select
     call term%connected%trace%set_only_matrix_element &
          (1, cmplx (sum (sqme_mism) * term%weight, 0, default))
     if (term%connected%has_matrix) then
        select type (config => term%pcm_instance%config)
        type is (pcm_nlo_t)
           call refill_evaluator (cmplx (sqme_mism * term%weight, 0, default), &
                config%get_qn (.true.), config%region_data%get_flavor_indices (.true.), &
                term%connected%matrix)
        end select
     end if
   end subroutine term_instance_evaluate_sqme_mismatch
 
 @ %def term_instance_evaluate_sqme_mismatch
 @
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_sqme_dglap => term_instance_evaluate_sqme_dglap
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_sqme_dglap (term, alpha_s)
     class(term_instance_t), intent(inout) :: term
     real(default), intent(in) :: alpha_s
     real(default), dimension(:), allocatable :: sqme_dglap
     integer :: i_flv
     if (term%nlo_type /= NLO_DGLAP) call msg_fatal &
        ("Trying to evaluate DGLAP remnant with unsuited term_instance.")
     call msg_debug2 (D_PROCESS_INTEGRATION, "term_instance_evaluate_sqme_dglap")
     select type (pcm_instance => term%pcm_instance)
     type is (pcm_instance_nlo_t)
        if (debug2_active (D_PROCESS_INTEGRATION)) then
           associate (n_flv => pcm_instance%dglap_remnant%n_flv)
              print *, "size(sqme_born) = ", size (pcm_instance%dglap_remnant%sqme_born)
              call term%connected%trace%write ()
              do i_flv = 1, n_flv
                 print *, "i_flv = ", i_flv, ", n_flv = ", n_flv
                 print *, "sqme_born(i_flv) = ", pcm_instance%dglap_remnant%sqme_born(i_flv)
              end do
           end associate
        end if
        call pcm_instance%compute_sqme_dglap_remnant (alpha_s, &
             term%connected%has_matrix, sqme_dglap)
     end select
     call term%connected%trace%set_only_matrix_element &
          (1, cmplx (sum (sqme_dglap) * term%weight, 0, default))
     if (term%connected%has_matrix) then
        select type (config => term%pcm_instance%config)
        type is (pcm_nlo_t)
           call refill_evaluator (cmplx (sqme_dglap * term%weight, 0, default), &
                config%get_qn (.true.), &
                config%region_data%get_flavor_indices (.true.), &
                term%connected%matrix)
        end select
     end if
   end subroutine term_instance_evaluate_sqme_dglap
 
 @ %def term_instance_evaluate_sqme_dglap
 @ Reset the term instance: clear the parton-state expressions and deactivate.
 <<Instances: term instance: TBP>>=
   procedure :: reset => term_instance_reset
 <<Instances: procedures>>=
   subroutine term_instance_reset (term)
     class(term_instance_t), intent(inout) :: term
     call term%connected%reset_expressions ()
     if (allocated (term%alpha_qcd_forced))  deallocate (term%alpha_qcd_forced)
     term%active = .false.
   end subroutine term_instance_reset
 
 @ %def term_instance_reset
 @ Force an $\alpha_s$ value that should be used in the matrix-element
 calculation.
 <<Instances: term instance: TBP>>=
   procedure :: set_alpha_qcd_forced => term_instance_set_alpha_qcd_forced
 <<Instances: procedures>>=
   subroutine term_instance_set_alpha_qcd_forced (term, alpha_qcd)
     class(term_instance_t), intent(inout) :: term
     real(default), intent(in) :: alpha_qcd
     if (allocated (term%alpha_qcd_forced)) then
        term%alpha_qcd_forced = alpha_qcd
     else
        allocate (term%alpha_qcd_forced, source = alpha_qcd)
     end if
   end subroutine term_instance_set_alpha_qcd_forced
 
 @ %def term_instance_set_alpha_qcd_forced
 @ Complete the kinematics computation for the effective parton states.
 
 We assume that the [[compute_hard_kinematics]] method of the process
 component instance has already been called, so the [[int_hard]]
 contains the correct hard kinematics.  The duty of this procedure is
 first to compute the effective kinematics and store this in the
 [[int_eff]] effective interaction inside the [[isolated]] parton
 state.  The effective kinematics may differ from the kinematics in the hard
 interaction.  It may involve parton recombination or parton splitting.
 The [[rearrange_partons]] method is responsible for this part.
 
 We may also call a method to compute the effective structure-function
 chain at this point.  This is not implemented yet.
 
 In the simple case that no rearrangement is necessary, as indicated by
 the [[rearrange]] flag, the effective interaction is a pointer to the
 hard interaction, and we can skip the rearrangement method.  Similarly
 for the effective structure-function chain.  (If we have an algorithm
 that uses rarrangement, it should evaluate [[k_term]] explicitly.)
 
 The final step of kinematics setup is to transfer the effective
 kinematics to the evaluators and to the [[subevt]].
 <<Instances: term instance: TBP>>=
   procedure :: compute_eff_kinematics => &
        term_instance_compute_eff_kinematics
 <<Instances: procedures>>=
   subroutine term_instance_compute_eff_kinematics (term)
     class(term_instance_t), intent(inout) :: term
     term%checked = .false.
     term%passed = .false.
     call term%isolated%receive_kinematics ()
     call term%connected%receive_kinematics ()
   end subroutine term_instance_compute_eff_kinematics
 
 @ %def term_instance_compute_eff_kinematics
 @ Inverse.  Reconstruct the connected state from the momenta in the
 trace evaluator (which we assume to be set), then reconstruct the
 isolated state as far as possible.  The second part finalizes the
 momentum configuration, using the incoming seed momenta
 <<Instances: term instance: TBP>>=
   procedure :: recover_hard_kinematics => &
        term_instance_recover_hard_kinematics
 <<Instances: procedures>>=
   subroutine term_instance_recover_hard_kinematics (term)
     class(term_instance_t), intent(inout) :: term
     term%checked = .false.
     term%passed = .false.
     call term%connected%send_kinematics ()
     call term%isolated%send_kinematics ()
   end subroutine term_instance_recover_hard_kinematics
 
 @ %def term_instance_recover_hard_kinematics
 @ Check the term whether it passes cuts and, if successful, evaluate
 scales and weights.  The factorization scale is also given to the term
 kinematics, enabling structure-function evaluation.
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_expressions => &
        term_instance_evaluate_expressions
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_expressions (term, scale_forced)
     class(term_instance_t), intent(inout) :: term
     real(default), intent(in), allocatable, optional :: scale_forced
     call term%connected%evaluate_expressions (term%passed, &
          term%scale, term%fac_scale, term%ren_scale, term%weight, &
          scale_forced, force_evaluation = .true.)
     term%checked = .true.
   end subroutine term_instance_evaluate_expressions
 
 @ %def term_instance_evaluate_expressions
 @ Evaluate the trace: first evaluate the hard interaction, then the trace
 evaluator.  We use the [[evaluate_interaction]] method of the process
 component which generated this term.  The [[subevt]] and cut expressions are
 not yet filled.
 
 The [[component]] argument is intent(inout) because the [[compute_amplitude]]
 method may modify the [[core_state]] workspace object.
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_interaction => term_instance_evaluate_interaction
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_interaction (term, core)
     class(term_instance_t), intent(inout) :: term
     class(prc_core_t), intent(in), pointer :: core
     call msg_debug2 (D_PROCESS_INTEGRATION, &
          "term_instance_evaluate_interaction")
     term%p_hard = term%int_hard%get_momenta ()
     select type (core)
     class is (prc_user_defined_base_t)
        call term%evaluate_interaction_userdef (core)
     class default
        call term%evaluate_interaction_default (core)
     end select
     call term%int_hard%set_matrix_element (term%amp)
   end subroutine term_instance_evaluate_interaction
 
 @ %def term_instance_evaluate_interaction
 @
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_interaction_default &
      => term_instance_evaluate_interaction_default
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_interaction_default (term, core)
     class(term_instance_t), intent(inout) :: term
     class(prc_core_t), intent(in) :: core
     integer :: i
     do i = 1, term%config%n_allowed
        term%amp(i) = core%compute_amplitude (term%config%i_term, term%p_hard, &
             term%config%flv(i), term%config%hel(i), term%config%col(i), &
             term%fac_scale, term%ren_scale, term%alpha_qcd_forced, &
             term%core_state)
     end do
     select type (pcm_instance => term%pcm_instance)
     type is (pcm_instance_nlo_t)
        call pcm_instance%set_fac_scale (term%fac_scale)
     end select
   end subroutine term_instance_evaluate_interaction_default
 
 @ %def term_instance_evaluate_interaction_default
 @
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_interaction_userdef &
      => term_instance_evaluate_interaction_userdef
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_interaction_userdef (term, core)
     class(term_instance_t), intent(inout) :: term
     class(prc_core_t), intent(inout) :: core
     call msg_debug2 (D_PROCESS_INTEGRATION, &
          "term_instance_evaluate_interaction_userdef")
     select type (core_state => term%core_state)
     type is (openloops_state_t)
        select type (core)
        type is (prc_openloops_t)
           call core%compute_alpha_s (core_state, term%ren_scale)
           if (allocated (core_state%threshold_data)) &
                call evaluate_threshold_parameters (core_state, core, term%k_term%phs%get_sqrts ())
        end select
     class is (user_defined_state_t)
        select type (core)
        class is (prc_user_defined_base_t)
           call core%compute_alpha_s (core_state, term%ren_scale)
        end select
     end select
     call evaluate_threshold_interaction ()
     if (term%nlo_type == NLO_VIRTUAL) then
        call term%evaluate_interaction_userdef_loop (core)
     else
        call term%evaluate_interaction_userdef_tree (core)
     end if
     select type (pcm_instance => term%pcm_instance)
     type is (pcm_instance_nlo_t)
        call pcm_instance%set_fac_scale (term%fac_scale)
     end select
 
 
   contains
     subroutine evaluate_threshold_parameters (core_state, core, sqrts)
        type(openloops_state_t), intent(inout) :: core_state
        type(prc_openloops_t), intent(inout) :: core
        real(default), intent(in) :: sqrts
        real(default) :: mtop, wtop
        mtop = m1s_to_mpole (sqrts)
        wtop = core_state%threshold_data%compute_top_width &
               (mtop, core_state%alpha_qcd)
        call core%set_mass_and_width (6, mtop, wtop)
     end subroutine
 
     subroutine evaluate_threshold_interaction ()
        integer :: leg
        select type (core)
        type is (prc_threshold_t)
           if (term%nlo_type > BORN) then
              select type (pcm => term%pcm_instance)
              type is (pcm_instance_nlo_t)
                 if (term%k_term%emitter >= 0) then
                    call core%set_offshell_momenta &
                         (pcm%real_kinematics%p_real_cms%get_momenta(term%config%i_term))
                    leg = thr_leg (term%k_term%emitter)
                    call core%set_leg (leg)
                    call core%set_onshell_momenta &
                         (pcm%real_kinematics%p_real_onshell(leg)%get_momenta(term%config%i_term))
                 else
                    call core%set_leg (0)
                    call core%set_offshell_momenta &
                         (pcm%real_kinematics%p_born_cms%get_momenta(1))
                 end if
              end select
           else
              call core%set_leg (-1)
              call core%set_offshell_momenta (term%p_hard)
           end if
        end select
     end subroutine evaluate_threshold_interaction
   end subroutine term_instance_evaluate_interaction_userdef
 
 @ %def term_instance_evaluate_interaction_userdef
 @ Retrieve the matrix elements from a matrix element provider and place them
 into [[term%amp]].
 
 For the handling of NLO calculations, FKS applies a book keeping handling
 flavor and/or particle type (e.g. for QCD: quark/gluon and quark flavor) in
 order to calculate the subtraction terms. Therefore, we have to insert the
 calculated matrix elements correctly into the state matrix where each entry
 corresponds to a set of quantum numbers. We apply a mapping [[hard_qn_ind]] from a list of
 quantum numbers provided by FKS to the hard process [[int_hard]].
 
 The calculated matrix elements are insert into [[term%amp]] in the following
 way. The first [[n_born]] particles are the matrix element of the hard process.
 In non-trivial beams, we store another [[n_beam_structure_int]] copies of these
 matrix elements as the first [[n_beam_structure_int]] subtractions.
 The next $n_{\text{born}}\times n_{sub}$ are color-correlated born matrix elements.
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_interaction_userdef_tree &
      => term_instance_evaluate_interaction_userdef_tree
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_interaction_userdef_tree (term, core)
     class(term_instance_t), intent(inout) :: term
     class(prc_core_t), intent(inout) :: core
     real(default) :: sqme
     real(default), dimension(:), allocatable :: sqme_color_c
     real(default), dimension(:), allocatable :: sqme_spin_c
     real(default), dimension(16) :: sqme_spin_c_tmp
     integer :: n_flv, n_hel, n_sub_color, n_sub_spin, n_pdf_off
     integer :: i_flv, i_hel, i_sub, i_color_c, i_spin_c, i_emitter
     integer :: emitter
     logical :: bad_point, bp
     call msg_debug2 (D_PROCESS_INTEGRATION, &
          "term_instance_evaluate_interaction_userdef_tree")
     allocate (sqme_color_c (blha_result_array_size &
          (term%int_hard%get_n_tot (), BLHA_AMP_COLOR_C)))
     n_flv = term%hard_qn_index%get_n_flv ()
     n_hel = term%hard_qn_index%get_n_hel ()
     n_sub_color = term%get_n_sub_color ()
     n_sub_spin = term%get_n_sub_spin ()
     do i_flv = 1, n_flv
        do i_hel = 1, n_hel
           select type (core)
           class is (prc_user_defined_base_t)
              call core%update_alpha_s (term%core_state, term%fac_scale)
              call core%compute_sqme (i_flv, i_hel, term%p_hard, term%ren_scale, &
                   sqme, bad_point)
              call term%pcm_instance%set_bad_point (bad_point)
              associate (i_int => term%hard_qn_index%get_index (i_flv = i_flv, i_hel = i_hel, i_sub = 0))
                term%amp(i_int) = cmplx (sqme, 0, default)
              end associate
           end select
           n_pdf_off = 0
           if (term%pcm_instance%config%has_pdfs .and. &
                (term%is_subtraction () .or. term%nlo_type == NLO_DGLAP)) then
              n_pdf_off = n_pdf_off + n_beam_structure_int
              do i_sub = 1, n_pdf_off
                 term%amp(term%hard_qn_index%get_index (i_flv, i_hel, i_sub)) = &
                      term%amp(term%hard_qn_index%get_index (i_flv, i_hel, i_sub = 0))
              end do
           end if
           if ((term%nlo_type == NLO_REAL .and. term%is_subtraction ()) .or. &
                term%nlo_type == NLO_MISMATCH) then
              sqme_color_c = zero
              select type (core)
              class is (prc_blha_t)
                 call core%compute_sqme_color_c_raw (i_flv, i_hel, term%p_hard, term%ren_scale, &
                      sqme_color_c, bad_point)
                 call term%pcm_instance%set_bad_point (bad_point)
              end select
              do i_sub = 1, n_sub_color
                 i_color_c = term%hard_qn_index%get_index (i_flv, i_hel, i_sub + n_pdf_off)
                 term%amp(i_color_c) = cmplx (sqme_color_c(i_sub), 0, default)
              end do
              if (n_sub_spin > 0) then
                 bad_point = .false.
                 allocate (sqme_spin_c(0))
                 select type (core)
                 type is (prc_openloops_t)
                    select type (config => term%pcm_instance%config)
                    type is (pcm_nlo_t)
                       do i_emitter = 1, config%region_data%n_emitters
                          emitter = config%region_data%emitters(i_emitter)
                          if (emitter > 0) then
                             call core%compute_sqme_spin_c (i_flv, i_hel, emitter, &
                                  term%p_hard, term%ren_scale, sqme_spin_c_tmp, bp)
                             sqme_spin_c = [sqme_spin_c, sqme_spin_c_tmp]
                             bad_point = bad_point .or. bp
                          end if
                       end do
                    end select
                    do i_sub = 1, n_sub_spin
                       i_spin_c = term%hard_qn_index%get_index (i_flv, i_hel, &
                            i_sub + n_pdf_off + n_sub_color)
                       term%amp(i_spin_c) = cmplx (sqme_spin_c(i_sub), 0, default)
                    end do
                 end select
                 deallocate (sqme_spin_c)
              end if
           end if
        end do
     end do
   end subroutine term_instance_evaluate_interaction_userdef_tree
 
 @ %def term_instance_evaluate_interaction_userdef_tree
 @
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_interaction_userdef_loop &
      => term_instance_evaluate_interaction_userdef_loop
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_interaction_userdef_loop (term, core)
     class(term_instance_t), intent(inout) :: term
     class(prc_core_t), intent(in) :: core
     integer :: n_hel, n_sub, n_flv
     integer :: i, i_flv, i_hel, i_sub, i_virt, i_color_c
     real(default), dimension(4) :: sqme_virt
     real(default), dimension(:), allocatable :: sqme_color_c
     logical :: bad_point
     call msg_debug (D_PROCESS_INTEGRATION, &
          "term_instance_evaluate_interaction_userdef_loop")
     allocate (sqme_color_c (blha_result_array_size &
          (term%int_hard%get_n_tot (), BLHA_AMP_COLOR_C)))
     n_flv = term%hard_qn_index%get_n_flv ()
     n_hel = term%hard_qn_index%get_n_hel ()
     n_sub = term%hard_qn_index%get_n_sub ()
     i_virt = 1
     do i_flv = 1, n_flv
        do i_hel = 1, n_hel
           select type (core)
           class is (prc_user_defined_base_t)
              call core%compute_sqme_virt (i_flv, i_hel, term%p_hard, &
                   term%ren_scale, sqme_virt, bad_point)
              call term%pcm_instance%set_bad_point (bad_point)
           end select
           associate (i_born => term%hard_qn_index%get_index (i_flv, i_hel = i_hel, i_sub = 0), &
                i_loop => term%hard_qn_index%get_index (i_flv, i_hel = i_hel, i_sub = i_virt))
             term%amp(i_loop) = cmplx (sqme_virt(3), 0, default)
             term%amp(i_born) = cmplx (sqme_virt(4), 0, default)
           end associate
           select type (config => term%pcm_instance%config)
           type is (pcm_nlo_t)
              select type (core)
              class is (prc_blha_t)
                 call core%compute_sqme_color_c_raw (i_flv, i_hel, term%p_hard, term%ren_scale, &
                      sqme_color_c, bad_point)
                 call term%pcm_instance%set_bad_point (bad_point)
                 do i_sub = 1 + i_virt, n_sub
                    i_color_c = term%hard_qn_index%get_index (i_flv, i_hel = i_hel, i_sub = i_sub)
                    ! Index shift: i_sub - i_virt
                    term%amp(i_color_c) = cmplx (sqme_color_c(i_sub - i_virt), 0, default)
                 end do
              end select
           end select
        end do
     end do
   end subroutine term_instance_evaluate_interaction_userdef_loop
 
 @ %def term_instance_evaluate_interaction_userdef_loop
 @ Evaluate the trace.  First evaluate the
 structure-function chain (i.e., the density matrix of the incoming
 partons).  Do this twice, in case the sf-chain instances within
 [[k_term]] and [[isolated]] differ.  Next, evaluate the hard
 interaction, then compute the convolution with the initial state.
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_trace => term_instance_evaluate_trace
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_trace (term)
     class(term_instance_t), intent(inout) :: term
     class(sf_rescale_t), allocatable :: func
     call term%k_term%evaluate_sf_chain (term%fac_scale)
     call term%evaluate_scaled_sf_chains ()
     call term%isolated%evaluate_sf_chain (term%fac_scale)
     call term%isolated%evaluate_trace ()
     call term%connected%evaluate_trace ()
   end subroutine term_instance_evaluate_trace
 
 @ %def term_instance_evaluate_trace
 @ Include rescaled structure functions due to NLO calculation.
 We rescale the structure function for the real subtraction [[sf_rescale_collinear]], the collinear
 counter terms [[sf_rescale_dglap_t]] and for the case, we have an emitter in the initial state,
 rescale the kinematics for it using [[sf_rescale_real_t]].
 
 References: arXiv:0709.2092, (2.35)-(2.42).
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_scaled_sf_chains => term_instance_evaluate_scaled_sf_chains
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_scaled_sf_chains (term)
     class(term_instance_t), intent(inout) :: term
     class(sf_rescale_t), allocatable :: func
     integer :: i_sub
     if (.not. term%pcm_instance%config%has_pdfs) return
     if (term%nlo_type == NLO_REAL) then
        if (term%is_subtraction ()) then
           allocate (sf_rescale_collinear_t :: func)
           select type (pcm => term%pcm_instance)
           type is (pcm_instance_nlo_t)
              select type (func)
              type is (sf_rescale_collinear_t)
                 call func%set (pcm%real_kinematics%xi_tilde)
                 call func%set_gluons (.true.)
              end select
           end select
           call term%k_term%sf_chain%evaluate (term%fac_scale, func)
           deallocate (func)
        else if (term%k_term%emitter >= 0 .and. term%k_term%emitter <= term%k_term%n_in) then
           allocate (sf_rescale_real_t :: func)
           select type (pcm => term%pcm_instance)
           type is (pcm_instance_nlo_t)
              select type (func)
              type is (sf_rescale_real_t)
                 call func%set (pcm%real_kinematics%xi_tilde * &
                      pcm%real_kinematics%xi_max (term%k_term%i_phs), &
                      pcm%real_kinematics%y (term%k_term%i_phs))
                 ! TODO sbrass Obviously, it is completely irrelevant,
                 ! TODO sbrass which beam is treated for hadronic beams. It becomes
                 ! TODO sbrass problematic when handling "e, p"-beams.
                 call func%restrict_to_beam (term%k_term%emitter)
              end select
           end select
           call term%k_term%sf_chain%evaluate (term%fac_scale, func)
           deallocate (func)
        else
           call term%k_term%sf_chain%evaluate (term%fac_scale)
        end if
     else if (term%nlo_type == NLO_DGLAP) then
        allocate (sf_rescale_dglap_t :: func)
        select type (pcm => term%pcm_instance)
        type is (pcm_instance_nlo_t)
           select type (func)
           type is (sf_rescale_dglap_t)
              call func%set (pcm%isr_kinematics%z)
              call func%set_gluons (.true.)
           end select
        end select
        call term%k_term%sf_chain%evaluate (term%fac_scale, func)
        deallocate (func)
     end if
   end subroutine term_instance_evaluate_scaled_sf_chains
 
 @ %def term_instance_evaluate_scaled_sf_chains
 @ Evaluate the extra data that we need for processing the object as a
 physical event.
 <<Instances: term instance: TBP>>=
   procedure :: evaluate_event_data => term_instance_evaluate_event_data
 <<Instances: procedures>>=
   subroutine term_instance_evaluate_event_data (term)
     class(term_instance_t), intent(inout) :: term
     logical :: only_momenta
     only_momenta = term%nlo_type > BORN
     call term%isolated%evaluate_event_data (only_momenta)
     call term%connected%evaluate_event_data (only_momenta)
   end subroutine term_instance_evaluate_event_data
 
 @ %def term_instance_evaluate_event_data
 @
 <<Instances: term instance: TBP>>=
   procedure :: set_fac_scale => term_instance_set_fac_scale
 <<Instances: procedures>>=
   subroutine term_instance_set_fac_scale (term, fac_scale)
     class(term_instance_t), intent(inout) :: term
     real(default), intent(in) :: fac_scale
     term%fac_scale = fac_scale
   end subroutine term_instance_set_fac_scale
 
 @ %def term_instance_set_fac_scale
 @ Return data that might be useful for external processing.  The
 factorization scale:
 <<Instances: term instance: TBP>>=
   procedure :: get_fac_scale => term_instance_get_fac_scale
 <<Instances: procedures>>=
   function term_instance_get_fac_scale (term) result (fac_scale)
     class(term_instance_t), intent(in) :: term
     real(default) :: fac_scale
     fac_scale = term%fac_scale
   end function term_instance_get_fac_scale
 
 @ %def term_instance_get_fac_scale
 @ We take the strong coupling from the process core.  The value is calculated
 when a new event is requested, so we should call it only after the event has
 been evaluated.  If it is not available there (a negative number is returned),
 we take the value stored in the term configuration, which should be determined
 by the model.  If the model does not provide a value, the result is zero.
 <<Instances: term instance: TBP>>=
   procedure :: get_alpha_s => term_instance_get_alpha_s
 <<Instances: procedures>>=
   function term_instance_get_alpha_s (term, core) result (alpha_s)
     class(term_instance_t), intent(in) :: term
     class(prc_core_t), intent(in) :: core
     real(default) :: alpha_s
     alpha_s = core%get_alpha_s (term%core_state)
     if (alpha_s < zero)  alpha_s = term%config%alpha_s
   end function term_instance_get_alpha_s
 
 @ %def term_instance_get_alpha_s
 @
 <<Instances: term instance: TBP>>=
   procedure :: reset_phs_identifiers => term_instance_reset_phs_identifiers
 <<Instances: procedures>>=
   subroutine term_instance_reset_phs_identifiers (term)
     class(term_instance_t), intent(inout) :: term
     select type (phs => term%k_term%phs)
     type is (phs_fks_t)
        phs%phs_identifiers%evaluated = .false.
     end select
   end subroutine term_instance_reset_phs_identifiers
 
 @ %def term_instance_reset_phs_identifiers
 @ The second helicity for [[helicities]] comes with a minus sign
 because OpenLoops inverts the helicity index of antiparticles.
 <<Instances: term instance: TBP>>=
   procedure :: get_helicities_for_openloops => term_instance_get_helicities_for_openloops
 <<Instances: procedures>>=
   subroutine term_instance_get_helicities_for_openloops (term, helicities)
     class(term_instance_t), intent(in) :: term
     integer, dimension(:,:), allocatable, intent(out) :: helicities
     type(helicity_t), dimension(:), allocatable :: hel
     type(quantum_numbers_t), dimension(:,:), allocatable :: qn
     type(quantum_numbers_mask_t) :: qn_mask
     integer :: h, i, j, n_in
     call qn_mask%set_sub (1)
     call term%isolated%trace%get_quantum_numbers_mask (qn_mask, qn)
     n_in = term%int_hard%get_n_in ()
     allocate (helicities (size (qn, dim=1), n_in))
     allocate (hel (n_in))
     do i = 1, size (qn, dim=1)
        do j = 1, n_in
           hel(j) = qn(i, j)%get_helicity ()
           call hel(j)%diagonalize ()
           call hel(j)%get_indices (h, h)
           helicities (i, j) = h
        end do
     end do
   end subroutine term_instance_get_helicities_for_openloops
 
 @ %def term_instance_get_helicities_for_openloops
 @
 <<Instances: term instance: TBP>>=
   procedure :: get_boost_to_lab => term_instance_get_boost_to_lab
 <<Instances: procedures>>=
   function term_instance_get_boost_to_lab (term) result (lt)
     type(lorentz_transformation_t) :: lt
     class(term_instance_t), intent(in) :: term
     lt = term%k_term%phs%get_lorentz_transformation ()
   end function term_instance_get_boost_to_lab
 
 @ %def term_instance_get_boost_to_lab
 @
 <<Instances: term instance: TBP>>=
   procedure :: get_boost_to_cms => term_instance_get_boost_to_cms
 <<Instances: procedures>>=
   function term_instance_get_boost_to_cms (term) result (lt)
     type(lorentz_transformation_t) :: lt
     class(term_instance_t), intent(in) :: term
     lt = inverse (term%k_term%phs%get_lorentz_transformation ())
   end function term_instance_get_boost_to_cms
 
 @ %def term_instance_get_boost_to_cms
 @
 <<Instances: term instance: TBP>>=
   procedure :: get_i_term_global => term_instance_get_i_term_global
 <<Instances: procedures>>=
   elemental function term_instance_get_i_term_global (term) result (i_term)
     integer :: i_term
     class(term_instance_t), intent(in) :: term
     i_term = term%config%i_term_global
   end function term_instance_get_i_term_global
 
 @ %def term_instance_get_i_term_global
 @
 <<Instances: term instance: TBP>>=
   procedure :: is_subtraction => term_instance_is_subtraction
 <<Instances: procedures>>=
   elemental function term_instance_is_subtraction (term) result (sub)
     logical :: sub
     class(term_instance_t), intent(in) :: term
     sub = term%config%i_term_global == term%config%i_sub
   end function term_instance_is_subtraction
 
 @ %def term_instance_is_subtraction
 @ Retrieve [[n_sub]] which was calculated in [[process_term_setup_interaction]].
 <<Instances: term instance: TBP>>=
   procedure :: get_n_sub => term_instance_get_n_sub
   procedure :: get_n_sub_color => term_instance_get_n_sub_color
   procedure :: get_n_sub_spin => term_instance_get_n_sub_spin
 <<Instances: procedures>>=
   function term_instance_get_n_sub (term) result (n_sub)
     integer :: n_sub
     class(term_instance_t), intent(in) :: term
     n_sub = term%config%n_sub
   end function term_instance_get_n_sub
 
   function term_instance_get_n_sub_color (term) result (n_sub_color)
     integer :: n_sub_color
     class(term_instance_t), intent(in) :: term
     n_sub_color = term%config%n_sub_color
   end function term_instance_get_n_sub_color
 
   function term_instance_get_n_sub_spin (term) result (n_sub_spin)
     integer :: n_sub_spin
     class(term_instance_t), intent(in) :: term
     n_sub_spin = term%config%n_sub_spin
   end function term_instance_get_n_sub_spin
 
 @ %def term_instance_get_n_sub
 @ %def term_instance_get_n_sub_color
 @ %def term_instance_get_n_sub_spin
 @
 \subsection{The process instance}
 A process instance contains all process data that depend on the
 sampling point and thus change often.  In essence, it is an event
 record at the elementary (parton) level.  We do not call it such, to
 avoid confusion with the actual event records.  If decays are
 involved, the latter are compositions of several elementary processes
 (i.e., their instances).
 
 We implement the process instance as an extension of the
 [[mci_sampler_t]] that we need for computing integrals and generate
 events.
 
 The base type contains: the [[integrand]], the [[selected_channel]],
 the two-dimensional array [[x]] of parameters, and the one-dimensional
 array [[f]] of Jacobians.  These subobjects are public and used for
 communicating with the multi-channel integrator.
 
 The [[process]] pointer accesses the process of which this record is
 an instance.  It is required whenever the calculation needs invariant
 configuration data, therefore the process should stay in memory for
 the whole lifetime of its instances.
 
 The [[evaluation_status]] code is used to check the current status.
 In particular, failure at various stages is recorded there.
 
 The [[count]] object records process evaluations, broken down
 according to status.
 
 The [[sqme]] value is the single real number that results from
 evaluating and tracing the kinematics and matrix elements.  This
 is the number that is handed over to an integration routine.
 
 The [[weight]] value is the event weight.  It is defined when an event
 has been generated from the process instance, either weighted or
 unweighted.  The value is the [[sqme]] value times Jacobian weights
 from the integration, or unity, respectively.
 
 The [[i_mci]] index chooses a subset of components that are associated with
 a common parameter set and integrator, i.e., that are added coherently.
 
 The [[sf_chain]] subobject is a realization of the beam and
 structure-function configuration in the [[process]] object.  It is not
 used for calculation directly but serves as the template for the
 sf-chain instances that are contained in the [[component]] objects.
 
 The [[component]] subobjects determine the state of each component.
 
 The [[term]] subobjects are workspace for evaluating kinematics,
 matrix elements, cuts etc.
 
 The [[mci_work]] subobject contains the array of real input parameters (random
 numbers) that generates the kinematical point.  It also contains the workspace
 for the MC integrators.  The active entry of the [[mci_work]] array is
 selected by the [[i_mci]] index above.
 
 The [[hook]] pointer accesses a list of after evaluate objects which are
 evalutated after the matrix element.
 <<Instances: public>>=
   public :: process_instance_t
 <<Instances: types>>=
   type, extends (mci_sampler_t) :: process_instance_t
      type(process_t), pointer :: process => null ()
      integer :: evaluation_status = STAT_UNDEFINED
      real(default) :: sqme = 0
      real(default) :: weight = 0
      real(default) :: excess = 0
      integer :: i_mci = 0
      integer :: selected_channel = 0
      type(sf_chain_t) :: sf_chain
      type(term_instance_t), dimension(:), allocatable :: term
      type(mci_work_t), dimension(:), allocatable :: mci_work
      class(pcm_instance_t), allocatable :: pcm
      class(process_instance_hook_t), pointer :: hook => null ()
    contains
    <<Instances: process instance: TBP>>
   end type process_instance_t
 
 @ %def process_instance
 @
 Wrapper type for storing pointers to process instance objects in arrays.
 <<Instances: public>>=
   public :: process_instance_ptr_t
 <<Instances: types>>=
   type :: process_instance_ptr_t
      type(process_instance_t), pointer :: p => null ()
   end type process_instance_ptr_t
 
 @ %def process_instance_ptr_t
 @ The process hooks are first-in-last-out list of objects which are evalutaed
 after the phase space and matrixelement are evaluated. It is possible to
 retrieve the sampler object and read the sampler information.
 
 The hook object are part of the [[process_instance]] and therefore, share a
 common lifetime. A data transfer, after the usual lifetime of the
 [[process_instance]], is not provided, as such the finalisation procedure has to take care
 of this! E.g. write the object to file from which later the collected
 information can then be retrieved.
 <<Instances: public>>=
   public :: process_instance_hook_t
 <<Instances: types>>=
   type, abstract :: process_instance_hook_t
      class(process_instance_hook_t), pointer :: next => null ()
    contains
      procedure(process_instance_hook_init), deferred :: init
      procedure(process_instance_hook_final), deferred :: final
      procedure(process_instance_hook_evaluate), deferred :: evaluate
   end type process_instance_hook_t
 
 @ %def process_instance_hook_t
 @ We have to provide a [[init]], a [[final]] procedure and, for after evaluation, the
 [[evaluate]] procedure.
 
 The [[init]] procedures accesses [[var_list]] and current [[instance]] object.
 <<Instances: public>>=
   public :: process_instance_hook_final, process_instance_hook_evaluate
 <<Instances: interfaces>>=
   abstract interface
      subroutine process_instance_hook_init (hook, var_list, instance)
        import :: process_instance_hook_t, var_list_t, process_instance_t
        class(process_instance_hook_t), intent(inout), target :: hook
        type(var_list_t), intent(in) :: var_list
        class(process_instance_t), intent(in), target :: instance
      end subroutine process_instance_hook_init
 
      subroutine process_instance_hook_final (hook)
        import :: process_instance_hook_t
        class(process_instance_hook_t), intent(inout) :: hook
      end subroutine process_instance_hook_final
 
      subroutine process_instance_hook_evaluate (hook, instance)
        import :: process_instance_hook_t, process_instance_t
        class(process_instance_hook_t), intent(inout) :: hook
        class(process_instance_t), intent(in), target :: instance
      end subroutine process_instance_hook_evaluate
   end interface
 
 @ %def process_instance_hook_final, process_instance_hook_evaluate
 @ The output routine contains a header with the most relevant
 information about the process, copied from
 [[process_metadata_write]].  We mark the active components by an asterisk.
 
 The next section is the MC parameter input.  The following sections
 are written only if the evaluation status is beyond setting the
 parameters, or if the [[verbose]] option is set.
 <<Instances: process instance: TBP>>=
   procedure :: write_header => process_instance_write_header
   procedure :: write => process_instance_write
 <<Instances: procedures>>=
   subroutine process_instance_write_header (object, unit, testflag)
     class(process_instance_t), intent(in) :: object
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: testflag
     integer :: u
     u = given_output_unit (unit)
     call write_separator (u, 2)
     if (associated (object%process)) then
        call object%process%write_meta (u, testflag)
     else
        write (u, "(1x,A)") "Process instance [undefined process]"
        return
     end if
     write (u, "(3x,A)", advance = "no")  "status = "
     select case (object%evaluation_status)
     case (STAT_INITIAL);            write (u, "(A)")  "initialized"
     case (STAT_ACTIVATED);          write (u, "(A)")  "activated"
     case (STAT_BEAM_MOMENTA);       write (u, "(A)")  "beam momenta set"
     case (STAT_FAILED_KINEMATICS);  write (u, "(A)")  "failed kinematics"
     case (STAT_SEED_KINEMATICS);    write (u, "(A)")  "seed kinematics"
     case (STAT_HARD_KINEMATICS);    write (u, "(A)")  "hard kinematics"
     case (STAT_EFF_KINEMATICS);     write (u, "(A)")  "effective kinematics"
     case (STAT_FAILED_CUTS);        write (u, "(A)")  "failed cuts"
     case (STAT_PASSED_CUTS);        write (u, "(A)")  "passed cuts"
     case (STAT_EVALUATED_TRACE);    write (u, "(A)")  "evaluated trace"
        call write_separator (u)
        write (u, "(3x,A,ES19.12)")  "sqme   = ", object%sqme
     case (STAT_EVENT_COMPLETE);   write (u, "(A)")  "event complete"
        call write_separator (u)
        write (u, "(3x,A,ES19.12)")  "sqme   = ", object%sqme
        write (u, "(3x,A,ES19.12)")  "weight = ", object%weight
        if (.not. vanishes (object%excess)) &
             write (u, "(3x,A,ES19.12)")  "excess = ", object%excess
     case default;                 write (u, "(A)")  "undefined"
     end select
     if (object%i_mci /= 0) then
        call write_separator (u)
        call object%mci_work(object%i_mci)%write (u, testflag)
     end if
     call write_separator (u, 2)
   end subroutine process_instance_write_header
 
   subroutine process_instance_write (object, unit, testflag)
     class(process_instance_t), intent(in) :: object
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: testflag
     integer :: u, i
     u = given_output_unit (unit)
     call object%write_header (u)
     if (object%evaluation_status >= STAT_BEAM_MOMENTA) then
        call object%sf_chain%write (u)
        call write_separator (u, 2)
        if (object%evaluation_status >= STAT_SEED_KINEMATICS) then
           if (object%evaluation_status >= STAT_HARD_KINEMATICS) then
              call write_separator (u, 2)
              write (u, "(1x,A)") "Active terms:"
              if (any (object%term%active)) then
                 do i = 1, size (object%term)
                    if (object%term(i)%active) then
                       call write_separator (u)
                       call object%term(i)%write (u, &
                            show_eff_state = &
                            object%evaluation_status >= STAT_EFF_KINEMATICS, &
                            testflag = testflag)
                    end if
                 end do
              end if
           end if
           call write_separator (u, 2)
        end if
     end if
   end subroutine process_instance_write
 
 @ %def process_instance_write_header
 @ %def process_instance_write
 @ Initialization connects the instance with a process.  All initial
 information is transferred from the process object.  The process
 object contains templates for the interaction subobjects (beam and
 term), but no evaluators.  The initialization routine
 creates evaluators for the matrix element trace, other evaluators
 are left untouched.
 
 Before we start generating, we double-check if the process library
 has been updated after the process was initializated
 ([[check_library_sanity]]).  This may happen if between integration
 and event generation the library has been recompiled, so all links
 become broken.
 
 The [[instance]] object must have the [[target]] attribute (also in
 any caller) since the initialization routine assigns various pointers
 to subobject of [[instance]].
 <<Instances: process instance: TBP>>=
   procedure :: init => process_instance_init
 <<Instances: procedures>>=
   subroutine process_instance_init (instance, process)
     class(process_instance_t), intent(out), target :: instance
     type(process_t), intent(inout), target :: process
     integer :: i
     class(pcm_t), pointer :: pcm
     type(process_term_t) :: term
     integer :: i_born, i_real, i_real_fin
     call msg_debug (D_PROCESS_INTEGRATION, "process_instance_init")
     instance%process => process
     call instance%process%check_library_sanity ()
     call instance%setup_sf_chain (process%get_beam_config_ptr ())
     allocate (instance%mci_work (process%get_n_mci ()))
     do i = 1, size (instance%mci_work)
        call instance%process%init_mci_work (instance%mci_work(i), i)
     end do
     call instance%process%reset_selected_cores ()
     pcm => instance%process%get_pcm_ptr ()
     call pcm%allocate_instance (instance%pcm)
     call instance%pcm%link_config (pcm)
     select type (pcm)
     type is (pcm_nlo_t)
        !!! The process is kept when the integration is finalized, but not the
        !!! process_instance. Thus, we check whether pcm has been initialized
        !!! but set up the pcm_instance each time.
        i_real_fin = process%get_associated_real_fin (1)
        if (.not. pcm%initialized) then
           i_born = process%get_i_core_nlo_type (BORN)
           i_real = process%get_i_core_nlo_type (NLO_REAL, include_sub = .false.)
           term = process%get_term_ptr (process%get_i_term (i_real))
           call pcm%init_qn (process%get_model_ptr ())
           if (i_real_fin > 0) call pcm%allocate_ps_matching ()
           associate (var_list => process%get_var_list_ptr ())
              if (var_list%get_sval (var_str ("$dalitz_plot")) /= var_str ('')) &
                   call pcm%activate_dalitz_plot (var_list%get_sval (var_str ("$dalitz_plot")))
           end associate
        end if
        pcm%initialized = .true.
        select type (pcm_instance => instance%pcm)
        type is (pcm_instance_nlo_t)
           call pcm_instance%init_config (process%component_can_be_integrated (), &
                process%get_nlo_type_component (), process%get_sqrts (), i_real_fin, &
                process%get_model_ptr ())
        end select
     end select
     allocate (instance%term (process%get_n_terms ()))
     do i = 1, process%get_n_terms ()
        call instance%term(i)%init_from_process (process, i, instance%pcm, &
             instance%sf_chain)
     end do
     call instance%set_i_mci_to_real_component ()
     call instance%find_same_kinematics ()
     instance%evaluation_status = STAT_INITIAL
   end subroutine process_instance_init
 
 @ %def process_instance_init
 @
 @ Finalize all subobjects that may contain allocated pointers.
 <<Instances: process instance: TBP>>=
   procedure :: final => process_instance_final
 <<Instances: procedures>>=
   subroutine process_instance_final (instance)
     class(process_instance_t), intent(inout) :: instance
     class(process_instance_hook_t), pointer :: current
     integer :: i
     instance%process => null ()
     if (allocated (instance%mci_work)) then
        do i = 1, size (instance%mci_work)
           call instance%mci_work(i)%final ()
        end do
        deallocate (instance%mci_work)
     end if
     call instance%sf_chain%final ()
     if (allocated (instance%term)) then
        do i = 1, size (instance%term)
           call instance%term(i)%final ()
        end do
        deallocate (instance%term)
     end if
     call instance%pcm%final ()
     instance%evaluation_status = STAT_UNDEFINED
     do while (associated (instance%hook))
        current => instance%hook
        call current%final ()
        instance%hook => current%next
        deallocate (current)
     end do
     instance%hook => null ()
   end subroutine process_instance_final
 
 @ %def process_instance_final
 @ Revert the process instance to initial state.  We do not deallocate
 anything, just reset the state index and deactivate all components and
 terms.
 
 We do not reset the choice of the MCI set [[i_mci]] unless this is
 required explicitly.
 <<Instances: process instance: TBP>>=
   procedure :: reset => process_instance_reset
 <<Instances: procedures>>=
   subroutine process_instance_reset (instance, reset_mci)
     class(process_instance_t), intent(inout) :: instance
     logical, intent(in), optional :: reset_mci
     integer :: i
     call instance%process%reset_selected_cores ()
     do i = 1, size (instance%term)
        call instance%term(i)%reset ()
     end do
     instance%term%checked = .false.
     instance%term%passed = .false.
     instance%term%k_term%new_seed = .true.
     if (present (reset_mci)) then
        if (reset_mci)  instance%i_mci = 0
     end if
     instance%selected_channel = 0
     instance%evaluation_status = STAT_INITIAL
   end subroutine process_instance_reset
 
 @ %def process_instance_reset
 @
 \subsubsection{Integration and event generation}
 The sampler test should just evaluate the squared matrix element [[n_calls]]
 times, discarding the results, and return.  This can be done before
 integration, e.g., for timing estimates.
 <<Instances: process instance: TBP>>=
   procedure :: sampler_test => process_instance_sampler_test
 <<Instances: procedures>>=
   subroutine process_instance_sampler_test (instance, i_mci, n_calls)
     class(process_instance_t), intent(inout), target :: instance
     integer, intent(in) :: i_mci
     integer, intent(in) :: n_calls
     integer :: i_mci_work
     i_mci_work = instance%process%get_i_mci_work (i_mci)
     call instance%choose_mci (i_mci_work)
     call instance%reset_counter ()
     call instance%process%sampler_test (instance, n_calls, i_mci_work)
     call instance%process%set_counter_mci_entry (i_mci_work, instance%get_counter ())
   end subroutine process_instance_sampler_test
 
 @ %def process_instance_sampler_test
 @ Generate a weighted event.  We select one of the available MCI
 integrators by its index [[i_mci]] and thus generate an event for the
 associated (group of) process component(s).  The arguments exactly
 correspond to the initializer and finalizer above.
 
 The resulting event is stored in the [[process_instance]] object,
 which also holds the workspace of the integrator.
 
 Note: The [[process]] object contains the random-number state, which
 changes for each event.
 Otherwise, all volatile data are inside the [[instance]] object.
 <<Instances: process instance: TBP>>=
   procedure :: generate_weighted_event => process_instance_generate_weighted_event
 <<Instances: procedures>>=
   subroutine process_instance_generate_weighted_event (instance, i_mci)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_mci
     integer :: i_mci_work
     i_mci_work = instance%process%get_i_mci_work (i_mci)
     call instance%choose_mci (i_mci_work)
     associate (mci_work => instance%mci_work(i_mci_work))
        call instance%process%generate_weighted_event &
           (i_mci_work, mci_work, instance, &
            instance%keep_failed_events ())
     end associate
   end subroutine process_instance_generate_weighted_event
 
 @ %def process_instance_generate_weighted_event
 @
 <<Instances: process instance: TBP>>=
   procedure :: generate_unweighted_event => process_instance_generate_unweighted_event
 <<Instances: procedures>>=
   subroutine process_instance_generate_unweighted_event (instance, i_mci)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_mci
     integer :: i_mci_work
     i_mci_work = instance%process%get_i_mci_work (i_mci)
     call instance%choose_mci (i_mci_work)
     associate (mci_work => instance%mci_work(i_mci_work))
        call instance%process%generate_unweighted_event &
           (i_mci_work, mci_work, instance)
     end associate
   end subroutine process_instance_generate_unweighted_event
 
 @ %def process_instance_generate_unweighted_event
 @
 This replaces the event generation methods for the situation that the
 process instance object has been filled by other means (i.e., reading
 and/or recalculating its contents).  We just have to fill in missing
 MCI data, especially the event weight.
 <<Instances: process instance: TBP>>=
   procedure :: recover_event => process_instance_recover_event
 <<Instances: procedures>>=
   subroutine process_instance_recover_event (instance)
     class(process_instance_t), intent(inout) :: instance
     integer :: i_mci
     i_mci = instance%i_mci
     call instance%process%set_i_mci_work (i_mci)
     associate (mci_instance => instance%mci_work(i_mci)%mci)
       call mci_instance%fetch (instance, instance%selected_channel)
     end associate
   end subroutine process_instance_recover_event
 
 @ %def process_instance_recover_event
 @
 @ Activate the components and terms that correspond to a currently
 selected MCI parameter set.
 <<Instances: process instance: TBP>>=
   procedure :: activate => process_instance_activate
 <<Instances: procedures>>=
   subroutine process_instance_activate (instance)
     class(process_instance_t), intent(inout) :: instance
     integer :: i, j
     integer, dimension(:), allocatable :: i_term
     associate (mci_work => instance%mci_work(instance%i_mci))
        call instance%process%select_components (mci_work%get_active_components ())
     end associate
     associate (process => instance%process)
        do i = 1, instance%process%get_n_components ()
           if (instance%process%component_is_selected (i)) then
              allocate (i_term (size (process%get_component_i_terms (i))))
              i_term = process%get_component_i_terms (i)
              do j = 1, size (i_term)
                 instance%term(i_term(j))%active = .true.
              end do
           end if
           if (allocated (i_term)) deallocate (i_term)
        end do
     end associate
     instance%evaluation_status = STAT_ACTIVATED
   end subroutine process_instance_activate
 
 @ %def process_instance_activate
 @
 <<Instances: process instance: TBP>>=
   procedure :: find_same_kinematics => process_instance_find_same_kinematics
 <<Instances: procedures>>=
   subroutine process_instance_find_same_kinematics (instance)
     class(process_instance_t), intent(inout) :: instance
     integer :: i_term1, i_term2, k, n_same
     do i_term1 = 1, size (instance%term)
        if (.not. allocated (instance%term(i_term1)%same_kinematics)) then
           n_same = 1 !!! Index group includes the index of its term_instance
           do i_term2 = 1, size (instance%term)
              if (i_term1 == i_term2) cycle
              if (compare_md5s (i_term1, i_term2)) n_same = n_same + 1
           end do
           allocate (instance%term(i_term1)%same_kinematics (n_same))
           associate (same_kinematics1 => instance%term(i_term1)%same_kinematics)
              same_kinematics1 = 0
              k = 1
              do i_term2 = 1, size (instance%term)
                 if (compare_md5s (i_term1, i_term2)) then
                    same_kinematics1(k) = i_term2
                    k = k + 1
                 end if
              end do
              do k = 1, size (same_kinematics1)
                 if (same_kinematics1(k) == i_term1) cycle
                 i_term2 = same_kinematics1(k)
                 allocate (instance%term(i_term2)%same_kinematics (n_same))
                 instance%term(i_term2)%same_kinematics = same_kinematics1
              end do
           end associate
        end if
     end do
   contains
     function compare_md5s (i, j) result (same)
       logical :: same
       integer, intent(in) :: i, j
       character(32) :: md5sum_1, md5sum_2
       integer :: mode_1, mode_2
       mode_1 = 0; mode_2 = 0
       select type (phs => instance%term(i)%k_term%phs%config)
       type is (phs_fks_config_t)
          md5sum_1 = phs%md5sum_born_config
          mode_1 = phs%mode
       class default
          md5sum_1 = phs%md5sum_phs_config
       end select
       select type (phs => instance%term(j)%k_term%phs%config)
       type is (phs_fks_config_t)
          md5sum_2 = phs%md5sum_born_config
          mode_2 = phs%mode
       class default
          md5sum_2 = phs%md5sum_phs_config
       end select
       same = (md5sum_1 == md5sum_2) .and. (mode_1 == mode_2)
     end function compare_md5s
   end subroutine process_instance_find_same_kinematics
 
 @ %def process_instance_find_same_kinematics
 @
 <<Instances: process instance: TBP>>=
   procedure :: transfer_same_kinematics => process_instance_transfer_same_kinematics
 <<Instances: procedures>>=
   subroutine process_instance_transfer_same_kinematics (instance, i_term)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_term
     integer :: i, i_term_same
     associate (same_kinematics => instance%term(i_term)%same_kinematics)
        do i = 1, size (same_kinematics)
           i_term_same = same_kinematics(i)
           if (i_term_same /= i_term) then
              instance%term(i_term_same)%p_seed = instance%term(i_term)%p_seed
              associate (phs => instance%term(i_term_same)%k_term%phs)
                 call phs%set_lorentz_transformation &
                      (instance%term(i_term)%k_term%phs%get_lorentz_transformation ())
                 select type (phs)
                 type is (phs_fks_t)
                    call phs%set_momenta (instance%term(i_term_same)%p_seed)
                    call phs%set_reference_frames (.false.)
                 end select
              end associate
           end if
           instance%term(i_term_same)%k_term%new_seed = .false.
        end do
     end associate
   end subroutine process_instance_transfer_same_kinematics
 
 @ %def process_instance_transfer_same_kinematics
 @
 <<Instances: process instance: TBP>>=
   procedure :: redo_sf_chains => process_instance_redo_sf_chains
 <<Instances: procedures>>=
   subroutine process_instance_redo_sf_chains (instance, i_term, phs_channel)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in), dimension(:) :: i_term
     integer, intent(in) :: phs_channel
     integer :: i
     do i = 1, size (i_term)
        call instance%term(i_term(i))%redo_sf_chain &
             (instance%mci_work(instance%i_mci), phs_channel)
     end do
   end subroutine process_instance_redo_sf_chains
 
 @ %def process_instance_redo_sf_chains
 @ Integrate the process, using a previously initialized process
 instance.  We select one of the available MCI integrators by its index
 [[i_mci]] and thus integrate over (structure functions and) phase
 space for the associated (group of) process component(s).
 <<Instances: process instance: TBP>>=
   procedure :: integrate => process_instance_integrate
 <<Instances: procedures>>=
   subroutine process_instance_integrate (instance, i_mci, n_it, n_calls, &
        adapt_grids, adapt_weights, final, pacify)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_mci
     integer, intent(in) :: n_it
     integer, intent(in) :: n_calls
     logical, intent(in), optional :: adapt_grids
     logical, intent(in), optional :: adapt_weights
     logical, intent(in), optional :: final, pacify
     integer :: nlo_type, i_mci_work
     nlo_type = instance%process%get_component_nlo_type (i_mci)
     i_mci_work = instance%process%get_i_mci_work (i_mci)
     call instance%choose_mci (i_mci_work)
     call instance%reset_counter ()
     associate (mci_work => instance%mci_work(i_mci_work), &
                process => instance%process)
        call process%integrate (i_mci_work, mci_work, &
             instance, n_it, n_calls, adapt_grids, adapt_weights, &
             final, pacify, nlo_type = nlo_type)
        call process%set_counter_mci_entry (i_mci_work, instance%get_counter ())
     end associate
   end subroutine process_instance_integrate
 
 @ %def process_instance_integrate
 @ Subroutine of the initialization above: initialize the beam and
 structure-function chain template.  We establish pointers to the
 configuration data, so [[beam_config]] must have a [[target]]
 attribute.
 
 The resulting chain is not used directly for calculation.  It will
 acquire instances which are stored in the process-component instance
 objects.
 <<Instances: process instance: TBP>>=
   procedure :: setup_sf_chain => process_instance_setup_sf_chain
 <<Instances: procedures>>=
   subroutine process_instance_setup_sf_chain (instance, config)
     class(process_instance_t), intent(inout) :: instance
     type(process_beam_config_t), intent(in), target :: config
     integer :: n_strfun
     n_strfun = config%n_strfun
     if (n_strfun /= 0) then
        call instance%sf_chain%init (config%data, config%sf)
     else
        call instance%sf_chain%init (config%data)
     end if
     if (config%sf_trace) then
        call instance%sf_chain%setup_tracing (config%sf_trace_file)
     end if
   end subroutine process_instance_setup_sf_chain
 
 @ %def process_instance_setup_sf_chain
 @ This initialization routine should be called only for process
 instances which we intend as a source for physical events.  It
 initializes the evaluators in the parton states of the terms.  They
 describe the (semi-)exclusive transition matrix and the distribution
 of color flow for the partonic process, convoluted with the beam and
 structure-function chain.
 
 If the model is not provided explicitly, we may use the model instance that
 belongs to the process.  However, an explicit model allows us to override
 particle settings.
 <<Instances: process instance: TBP>>=
   procedure :: setup_event_data => process_instance_setup_event_data
 <<Instances: procedures>>=
   subroutine process_instance_setup_event_data (instance, model, i_core)
     class(process_instance_t), intent(inout), target :: instance
     class(model_data_t), intent(in), optional, target :: model
     integer, intent(in), optional :: i_core
     class(model_data_t), pointer :: current_model
     integer :: i
     class(prc_core_t), pointer :: core => null ()
     if (present (model)) then
        current_model => model
     else
        current_model => instance%process%get_model_ptr ()
     end if
     do i = 1, size (instance%term)
        associate (term => instance%term(i))
          if (associated (term%config)) then
             core => instance%process%get_core_term (i)
             call term%setup_event_data (core, current_model)
          end if
        end associate
     end do
     core => null ()
   end subroutine process_instance_setup_event_data
 
 @ %def process_instance_setup_event_data
 @ Choose a MC parameter set and the corresponding integrator.
 The choice persists beyond calls of the [[reset]] method above.  This method
 is automatically called here.
 <<Instances: process instance: TBP>>=
   procedure :: choose_mci => process_instance_choose_mci
 <<Instances: procedures>>=
   subroutine process_instance_choose_mci (instance, i_mci)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_mci
     instance%i_mci = i_mci
     call instance%reset ()
   end subroutine process_instance_choose_mci
 
 @ %def process_instance_choose_mci
 @ Explicitly set a MC parameter set.  Works only if we are in initial
 state.  We assume that the length of the parameter set is correct.
 
 After setting the parameters, activate the components and terms that
 correspond to the chosen MC parameter set.
 
 The [[warmup_flag]] is used when a dummy phase-space point is computed
 for the warmup of e.g. OpenLoops helicities. The setting of the
 the [[evaluation_status]] has to be avoided then.
 <<Instances: process instance: TBP>>=
   procedure :: set_mcpar => process_instance_set_mcpar
 <<Instances: procedures>>=
   subroutine process_instance_set_mcpar (instance, x, warmup_flag)
     class(process_instance_t), intent(inout) :: instance
     real(default), dimension(:), intent(in) :: x
     logical, intent(in), optional :: warmup_flag
     logical :: activate
     activate = .true.; if (present (warmup_flag)) activate = .not. warmup_flag
     if (instance%evaluation_status == STAT_INITIAL) then
        associate (mci_work => instance%mci_work(instance%i_mci))
           call mci_work%set (x)
        end associate
        if (activate) call instance%activate ()
     end if
   end subroutine process_instance_set_mcpar
 
 @ %def process_instance_set_mcpar
 @ Receive the beam momentum/momenta from a source interaction.  This
 applies to a cascade decay process instance, where the `beam' momentum
 varies event by event.
 
 The master beam momentum array is contained in the main structure
 function chain subobject [[sf_chain]].  The sf-chain instance that
 reside in the components will take their beam momenta from there.
 
 The procedure transforms the instance status into
 [[STAT_BEAM_MOMENTA]].  For process instance with fixed beam, this
 intermediate status is skipped.
 <<Instances: process instance: TBP>>=
   procedure :: receive_beam_momenta => process_instance_receive_beam_momenta
 <<Instances: procedures>>=
   subroutine process_instance_receive_beam_momenta (instance)
     class(process_instance_t), intent(inout) :: instance
     if (instance%evaluation_status >= STAT_INITIAL) then
        call instance%sf_chain%receive_beam_momenta ()
        instance%evaluation_status = STAT_BEAM_MOMENTA
     end if
   end subroutine process_instance_receive_beam_momenta
 
 @ %def process_instance_receive_beam_momenta
 @ Set the beam momentum/momenta explicitly.  Otherwise, analogous to
 the previous procedure.
 <<Instances: process instance: TBP>>=
   procedure :: set_beam_momenta => process_instance_set_beam_momenta
 <<Instances: procedures>>=
   subroutine process_instance_set_beam_momenta (instance, p)
     class(process_instance_t), intent(inout) :: instance
     type(vector4_t), dimension(:), intent(in) :: p
     if (instance%evaluation_status >= STAT_INITIAL) then
        call instance%sf_chain%set_beam_momenta (p)
        instance%evaluation_status = STAT_BEAM_MOMENTA
     end if
   end subroutine process_instance_set_beam_momenta
 
 @ %def process_instance_set_beam_momenta
 @ Recover the initial beam momenta (those in the [[sf_chain]]
 component), given a valid (recovered) [[sf_chain_instance]] in one of
 the active components.  We need to do this only if the lab frame is
 not the c.m.\ frame, otherwise those beams would be fixed anyway.
 <<Instances: process instance: TBP>>=
   procedure :: recover_beam_momenta => process_instance_recover_beam_momenta
 <<Instances: procedures>>=
   subroutine process_instance_recover_beam_momenta (instance, i_term)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_term
     if (.not. instance%process%lab_is_cm_frame ()) then
        if (instance%evaluation_status >= STAT_EFF_KINEMATICS) then
           call instance%term(i_term)%return_beam_momenta ()
        end if
     end if
   end subroutine process_instance_recover_beam_momenta
 
 @ %def process_instance_recover_beam_momenta
 @ Explicitly choose MC integration channel.  We assume here that the channel
 count is identical for all active components.
 <<Instances: process instance: TBP>>=
   procedure :: select_channel => process_instance_select_channel
 <<Instances: procedures>>=
   subroutine process_instance_select_channel (instance, channel)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: channel
     instance%selected_channel = channel
   end subroutine process_instance_select_channel
 
 @ %def process_instance_select_channel
 @ First step of process evaluation: set up seed kinematics.  That is, for each
 active process component, compute a momentum array from the MC input
 parameters.
 
 If [[skip_term]] is set, we skip the component that accesses this
 term.  We can assume that the associated data have already been
 recovered, and we are just computing the rest.
 <<Instances: process instance: TBP>>=
   procedure :: compute_seed_kinematics => &
        process_instance_compute_seed_kinematics
 <<Instances: procedures>>=
   subroutine process_instance_compute_seed_kinematics (instance, skip_term)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in), optional :: skip_term
     integer :: channel, skip_component, i, j
     logical :: success
     integer, dimension(:), allocatable :: i_term
     channel = instance%selected_channel
     if (channel == 0) then
        call msg_bug ("Compute seed kinematics: undefined integration channel")
     end if
     if (present (skip_term)) then
        skip_component = instance%term(skip_term)%config%i_component
     else
        skip_component = 0
     end if
     if (instance%evaluation_status >= STAT_ACTIVATED) then
        success = .true.
        do i = 1, instance%process%get_n_components ()
           if (i == skip_component)  cycle
           if (instance%process%component_is_selected (i)) then
              allocate (i_term (size (instance%process%get_component_i_terms (i))))
              i_term = instance%process%get_component_i_terms (i)
              do j = 1, size (i_term)
                 if (instance%term(i_term(j))%k_term%new_seed) then
                    call instance%term(i_term(j))%compute_seed_kinematics &
                         (instance%mci_work(instance%i_mci), channel, success)
                    call instance%transfer_same_kinematics (i_term(j))
                 end if
                 if (.not. success)  exit
                 call instance%term(i_term(j))%evaluate_projections ()
                 call instance%term(i_term(j))%evaluate_radiation_kinematics &
                        (instance%mci_work(instance%i_mci)%get_x_process ())
                 call instance%term(i_term(j))%generate_fsr_in ()
                 call instance%term(i_term(j))%compute_xi_ref_momenta ()
              end do
           end if
           if (allocated (i_term)) deallocate (i_term)
        end do
        if (success) then
           instance%evaluation_status = STAT_SEED_KINEMATICS
        else
           instance%evaluation_status = STAT_FAILED_KINEMATICS
        end if
     end if
     associate (mci_work => instance%mci_work(instance%i_mci))
        select type (pcm => instance%pcm)
        class is (pcm_instance_nlo_t)
           call pcm%set_x_rad (mci_work%get_x_process ())
        end select
     end associate
   end subroutine process_instance_compute_seed_kinematics
 
 @ %def process_instance_compute_seed_kinematics
 @
 <<Instances: process instance: TBP>>=
   procedure :: get_x_process => process_instance_get_x_process
 <<Instances: procedures>>=
   pure function process_instance_get_x_process (instance) result (x)
     real(default), dimension(:), allocatable :: x
     class(process_instance_t), intent(in) :: instance
     allocate (x(size (instance%mci_work(instance%i_mci)%get_x_process ())))
     x = instance%mci_work(instance%i_mci)%get_x_process ()
   end function process_instance_get_x_process
 
 @ %def process_instance_get_x_process
 @
 <<Instances: process instance: TBP>>=
   procedure :: get_active_component_type => process_instance_get_active_component_type
 <<Instances: procedures>>=
   pure function process_instance_get_active_component_type (instance) &
          result (nlo_type)
     integer :: nlo_type
     class(process_instance_t), intent(in) :: instance
     nlo_type = instance%process%get_component_nlo_type (instance%i_mci)
   end function process_instance_get_active_component_type
 
 @ %def process_instance_get_active_component_type
 @ Inverse: recover missing parts of the kinematics from the momentum
 configuration, which we know for a single term and component.   Given
 a channel, reconstruct the MC parameter set.
 <<Instances: process instance: TBP>>=
   procedure :: recover_mcpar => process_instance_recover_mcpar
 <<Instances: procedures>>=
   subroutine process_instance_recover_mcpar (instance, i_term)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_term
     integer :: channel
     if (instance%evaluation_status >= STAT_EFF_KINEMATICS) then
        channel = instance%selected_channel
        if (channel == 0) then
           call msg_bug ("Recover MC parameters: undefined integration channel")
        end if
        call instance%term(i_term)%recover_mcpar &
             (instance%mci_work(instance%i_mci), channel)
     end if
   end subroutine process_instance_recover_mcpar
 
 @ %def process_instance_recover_mcpar
 @ This is part of [[recover_mcpar]], extracted for the case when there is
 no phase space and parameters to recover, but we still need the structure
 function kinematics for evaluation.
 <<Instances: process instance: TBP>>=
   procedure :: recover_sfchain => process_instance_recover_sfchain
 <<Instances: procedures>>=
   subroutine process_instance_recover_sfchain (instance, i_term)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_term
     integer :: channel
     if (instance%evaluation_status >= STAT_EFF_KINEMATICS) then
        channel = instance%selected_channel
        if (channel == 0) then
           call msg_bug ("Recover sfchain: undefined integration channel")
        end if
        call instance%term(i_term)%recover_sfchain (channel)
     end if
   end subroutine process_instance_recover_sfchain
 
 @ %def process_instance_recover_sfchain
 @ Second step of process evaluation: compute all momenta, for all active
 components, from the seed kinematics.
 <<Instances: process instance: TBP>>=
   procedure :: compute_hard_kinematics => &
        process_instance_compute_hard_kinematics
 <<Instances: procedures>>=
   subroutine process_instance_compute_hard_kinematics (instance, skip_term)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in), optional :: skip_term
     integer :: i
     logical :: success
     success = .true.
     if (instance%evaluation_status >= STAT_SEED_KINEMATICS) then
        do i = 1, size (instance%term)
           if (instance%term(i)%active) then
              call instance%term(i)%compute_hard_kinematics (skip_term, success)
              if (.not. success) exit
              !!! Ren scale is zero when this is commented out! Understand!
              if (instance%term(i)%nlo_type == NLO_REAL) &
                   call instance%term(i)%redo_sf_chain (instance%mci_work(instance%i_mci), &
                        instance%selected_channel)
           end if
        end do
        if (success) then
           instance%evaluation_status = STAT_HARD_KINEMATICS
        else
           instance%evaluation_status = STAT_FAILED_KINEMATICS
        end if
     end if
   end subroutine process_instance_compute_hard_kinematics
 
 @ %def process_instance_setup_compute_hard_kinematics
 @ Inverse: recover seed kinematics.  We know the beam momentum
 configuration and the outgoing momenta of the effective interaction,
 for one specific term.
 <<Instances: process instance: TBP>>=
   procedure :: recover_seed_kinematics => &
        process_instance_recover_seed_kinematics
 <<Instances: procedures>>=
   subroutine process_instance_recover_seed_kinematics (instance, i_term)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_term
     if (instance%evaluation_status >= STAT_EFF_KINEMATICS) &
        call instance%term(i_term)%recover_seed_kinematics ()
   end subroutine process_instance_recover_seed_kinematics
 
 @ %def process_instance_recover_seed_kinematics
 @ Third step of process evaluation: compute the effective momentum
 configurations, for all active terms, from the hard kinematics.
 <<Instances: process instance: TBP>>=
   procedure :: compute_eff_kinematics => &
        process_instance_compute_eff_kinematics
 <<Instances: procedures>>=
   subroutine process_instance_compute_eff_kinematics (instance, skip_term)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in), optional :: skip_term
     integer :: i
     if (instance%evaluation_status >= STAT_HARD_KINEMATICS) then
        do i = 1, size (instance%term)
           if (present (skip_term)) then
              if (i == skip_term)  cycle
           end if
           if (instance%term(i)%active) then
              call instance%term(i)%compute_eff_kinematics ()
           end if
        end do
        instance%evaluation_status = STAT_EFF_KINEMATICS
     end if
   end subroutine process_instance_compute_eff_kinematics
 
 @ %def process_instance_setup_compute_eff_kinematics
 @ Inverse: recover the hard kinematics from effective kinematics for
 one term, then compute effective kinematics for the other terms.
 <<Instances: process instance: TBP>>=
   procedure :: recover_hard_kinematics => &
        process_instance_recover_hard_kinematics
 <<Instances: procedures>>=
   subroutine process_instance_recover_hard_kinematics (instance, i_term)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_term
     integer :: i
     if (instance%evaluation_status >= STAT_EFF_KINEMATICS) then
        call instance%term(i_term)%recover_hard_kinematics ()
        do i = 1, size (instance%term)
           if (i /= i_term) then
              if (instance%term(i)%active) then
                 call instance%term(i)%compute_eff_kinematics ()
              end if
           end if
        end do
        instance%evaluation_status = STAT_EFF_KINEMATICS
     end if
   end subroutine process_instance_recover_hard_kinematics
 
 @ %def recover_hard_kinematics
 @ Fourth step of process evaluation: check cuts for all terms.  Where
 sucessful, compute any scales and weights.  Otherwise, deactive the term.
 If any of the terms has passed, set the state to [[STAT_PASSED_CUTS]].
 
 The argument [[scale_forced]], if present, will override the scale calculation
 in the term expressions.
 <<Instances: process instance: TBP>>=
   procedure :: evaluate_expressions => &
        process_instance_evaluate_expressions
 <<Instances: procedures>>=
   subroutine process_instance_evaluate_expressions (instance, scale_forced)
     class(process_instance_t), intent(inout) :: instance
     real(default), intent(in), allocatable, optional :: scale_forced
     integer :: i
     logical :: passed_real
     if (instance%evaluation_status >= STAT_EFF_KINEMATICS) then
        do i = 1, size (instance%term)
           if (instance%term(i)%active) then
              call instance%term(i)%evaluate_expressions (scale_forced)
           end if
        end do
        call evaluate_real_scales_and_cuts ()
        if (.not. passed_real) then
           instance%evaluation_status = STAT_FAILED_CUTS
        else
           if (any (instance%term%passed)) then
              instance%evaluation_status = STAT_PASSED_CUTS
           else
              instance%evaluation_status = STAT_FAILED_CUTS
           end if
       end if
     end if
   contains
     subroutine evaluate_real_scales_and_cuts ()
       integer :: i
       passed_real = .true.
       select type (config => instance%pcm%config)
       type is (pcm_nlo_t)
          do i = 1, size (instance%term)
             if (instance%term(i)%active .and. instance%term(i)%nlo_type == NLO_REAL) then
                if (config%settings%cut_all_sqmes) &
                     passed_real = passed_real .and. instance%term(i)%passed
                if (config%settings%use_born_scale) &
                     call replace_scales (instance%term(i))
             end if
          end do
       end select
     end subroutine evaluate_real_scales_and_cuts
 
     subroutine replace_scales (this_term)
       type(term_instance_t), intent(inout) :: this_term
       integer :: i_sub
       i_sub = this_term%config%i_sub
       if (this_term%config%i_term_global /= i_sub .and. i_sub > 0) then
          this_term%ren_scale = instance%term(i_sub)%ren_scale
          this_term%fac_scale = instance%term(i_sub)%fac_scale
       end if
     end subroutine replace_scales
   end subroutine process_instance_evaluate_expressions
 
 @ %def process_instance_evaluate_expressions
 @ Fifth step of process evaluation: fill the parameters for the non-selected
 ,channels, that have not been used for seeding.  We should do this after
 evaluating cuts, since we may save some expensive calculations if the phase
 space point fails the cuts.
 
 If [[skip_term]] is set, we skip the component that accesses this
 term.  We can assume that the associated data have already been
 recovered, and we are just computing the rest.
 <<Instances: process instance: TBP>>=
   procedure :: compute_other_channels => &
        process_instance_compute_other_channels
 <<Instances: procedures>>=
   subroutine process_instance_compute_other_channels (instance, skip_term)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in), optional :: skip_term
     integer :: channel, skip_component, i, j
     integer, dimension(:), allocatable :: i_term
     channel = instance%selected_channel
     if (channel == 0) then
        call msg_bug ("Compute other channels: undefined integration channel")
     end if
     if (present (skip_term)) then
        skip_component = instance%term(skip_term)%config%i_component
     else
        skip_component = 0
     end if
     if (instance%evaluation_status >= STAT_PASSED_CUTS) then
        do i = 1, instance%process%get_n_components ()
           if (i == skip_component)  cycle
           if (instance%process%component_is_selected (i)) then
              allocate (i_term (size (instance%process%get_component_i_terms (i))))
              i_term = instance%process%get_component_i_terms (i)
              do j = 1, size (i_term)
                 call instance%term(i_term(j))%compute_other_channels &
                      (instance%mci_work(instance%i_mci), channel)
              end do
           end if
           if (allocated (i_term)) deallocate (i_term)
        end do
     end if
   end subroutine process_instance_compute_other_channels
 
 @ %def process_instance_compute_other_channels
 @ If not done otherwise, we an flag the kinematics as new for the core state,
 such that the routine below will actually compute the matrix element and not
 just look it up.
 <<Instances: process instance: TBP>>=
   procedure :: reset_core_kinematics => process_instance_reset_core_kinematics
 <<Instances: procedures>>=
   subroutine process_instance_reset_core_kinematics (instance)
     class(process_instance_t), intent(inout) :: instance
     integer :: i
     if (instance%evaluation_status >= STAT_PASSED_CUTS) then
        do i = 1, size (instance%term)
           associate (term => instance%term(i))
             if (term%active .and. term%passed) then
                if (allocated (term%core_state)) &
                     call term%core_state%reset_new_kinematics ()
             end if
           end associate
        end do
     end if
   end subroutine process_instance_reset_core_kinematics
 
 @ %def process_instance_reset_core_kinematics
 @ Sixth step of process evaluation: evaluate the matrix elements, and compute
 the trace (summed over quantum numbers) for all terms.  Finally, sum up the
 terms, iterating over all active process components.
 <<Instances: process instance: TBP>>=
   procedure :: evaluate_trace => process_instance_evaluate_trace
 <<Instances: procedures>>=
   subroutine process_instance_evaluate_trace (instance)
     class(process_instance_t), intent(inout) :: instance
     class(prc_core_t), pointer :: core => null ()
     integer :: i, i_real_fin
     real(default) :: alpha_s, alpha_qed
     class(prc_core_t), pointer :: core_sub => null ()
     class(model_data_t), pointer :: model => null ()
     call msg_debug2 (D_PROCESS_INTEGRATION, "process_instance_evaluate_trace")
     instance%sqme = zero
     call instance%reset_matrix_elements ()
     if (instance%evaluation_status >= STAT_PASSED_CUTS) then
        do i = 1, size (instance%term)
           associate (term => instance%term(i))
             if (term%active .and. term%passed) then
                core => instance%process%get_core_term (i)
                if (instance%pcm%config%is_nlo ()) &
                     core_sub => instance%process%get_subtraction_core ()
                call term%evaluate_interaction (core)
                call term%evaluate_trace ()
                i_real_fin = instance%process%get_associated_real_fin (1)
                if (instance%process%uses_real_partition ()) &
                     call term%apply_real_partition (instance%process)
                if (term%config%i_component /= i_real_fin) then
                   if ((term%nlo_type == NLO_REAL .and. term%k_term%emitter < 0) &
                        .or. term%nlo_type == NLO_MISMATCH &
                        .or. term%nlo_type == NLO_DGLAP) &
                        call term%set_born_sqmes (core)
                   if (term%nlo_type > BORN) then
                      if (.not. (term%nlo_type == NLO_REAL .and. term%k_term%emitter >= 0)) then
                         select type (config => term%pcm_instance%config)
                         type is (pcm_nlo_t)
                            if (char (config%settings%nlo_correction_type) == "QCD" .or. &
                                 char (config%settings%nlo_correction_type) == "Full") &
                                 call term%evaluate_color_correlations (core_sub)
                            if (char (config%settings%nlo_correction_type) == "QED" .or. &
                                 char (config%settings%nlo_correction_type) == "Full") &
                                 call term%evaluate_charge_correlations (core_sub)
                         end select
                      end if
                      if (term%is_subtraction ()) then
                         call term%evaluate_spin_correlations (core_sub)
                      end if
                      if ((term%is_subtraction () .or. term%nlo_type == NLO_DGLAP) &
                           .and. term%pcm_instance%config%has_pdfs) &
                           call term%compute_sqme_coll_isr ()
                   end if
                   alpha_s = core%get_alpha_s (term%core_state)
                   if (associated (instance%process%get_model_ptr ())) then
                      model => instance%process%get_model_ptr ()
                      if (associated (model%get_par_data_ptr (var_str ('alpha_em_i')))) &
                           alpha_qed = one / model%get_real (var_str ('alpha_em_i'))
                      model => null ()
                   end if
                   select case (term%nlo_type)
                   case (NLO_REAL)
                      call term%apply_fks (alpha_s, alpha_qed)
                   case (NLO_VIRTUAL)
                      call term%evaluate_sqme_virt (alpha_s, alpha_qed)
                   case (NLO_MISMATCH)
                      call term%evaluate_sqme_mismatch (alpha_s)
                   case (NLO_DGLAP)
                      call term%evaluate_sqme_dglap (alpha_s)
                   end select
                end if
             end if
             core_sub => null ()
             instance%sqme = instance%sqme + real (sum (&
                  term%connected%trace%get_matrix_element () * &
                  term%weight))
           end associate
        end do
        core => null ()
        if (instance%pcm%is_valid ()) then
           instance%evaluation_status = STAT_EVALUATED_TRACE
        else
           instance%evaluation_status = STAT_FAILED_KINEMATICS
        end if
     else
        !!! Failed kinematics or failed cuts: set sqme to zero
        instance%sqme = zero
     end if
   end subroutine process_instance_evaluate_trace
 
 @ %def process_instance_evaluate_trace
 <<Instances: term instance: TBP>>=
   procedure :: set_born_sqmes => term_instance_set_born_sqmes
 <<Instances: procedures>>=
   subroutine term_instance_set_born_sqmes (term, core)
     class(term_instance_t), intent(inout) :: term
     class(prc_core_t), intent(in) :: core
     integer :: i_flv, ii_flv
     real(default) :: sqme
     select type (pcm_instance => term%pcm_instance)
     type is (pcm_instance_nlo_t)
        do i_flv = 1, term%connected_qn_index%get_n_flv ()
           ii_flv = term%connected_qn_index%get_index (i_flv, i_sub = 0)
           sqme = real (term%connected%trace%get_matrix_element (ii_flv))
           select case (term%nlo_type)
           case (NLO_REAL)
              pcm_instance%real_sub%sqme_born(i_flv) = sqme
           case (NLO_MISMATCH)
              pcm_instance%soft_mismatch%sqme_born(i_flv) = sqme
           case (NLO_DGLAP)
              pcm_instance%dglap_remnant%sqme_born(i_flv) = sqme
           end select
        end do
     end select
   end subroutine term_instance_set_born_sqmes
 @
 <<Instances: process instance: TBP>>=
   procedure :: apply_real_partition => process_instance_apply_real_partition
 <<Instances: procedures>>=
   subroutine process_instance_apply_real_partition (instance)
     class(process_instance_t), intent(inout) :: instance
     integer :: i_component, i_term
     integer, dimension(:), allocatable :: i_terms
     associate (process => instance%process)
        i_component = process%get_first_real_component ()
        if (process%component_is_selected (i_component) .and. &
               process%get_component_nlo_type (i_component) == NLO_REAL) then
           allocate (i_terms (size (process%get_component_i_terms (i_component))))
           i_terms = process%get_component_i_terms (i_component)
           do i_term = 1, size (i_terms)
              call instance%term(i_terms(i_term))%apply_real_partition (process)
           end do
        end if
        if (allocated (i_terms)) deallocate (i_terms)
     end associate
   end subroutine process_instance_apply_real_partition
 
 @ %def process_instance_apply_real_partition
 @
 <<Instances: process instance: TBP>>=
   procedure :: set_i_mci_to_real_component => process_instance_set_i_mci_to_real_component
 <<Instances: procedures>>=
   subroutine process_instance_set_i_mci_to_real_component (instance)
     class(process_instance_t), intent(inout) :: instance
     integer :: i_mci, i_component
     type(process_component_t), pointer :: component => null ()
     select type (pcm_instance => instance%pcm)
     type is (pcm_instance_nlo_t)
        if (allocated (pcm_instance%i_mci_to_real_component)) then
           call msg_warning ("i_mci_to_real_component already allocated - replace it")
           deallocate (pcm_instance%i_mci_to_real_component)
        end if
        allocate (pcm_instance%i_mci_to_real_component (size (instance%mci_work)))
        do i_mci = 1, size (instance%mci_work)
           do i_component = 1, instance%process%get_n_components ()
              component => instance%process%get_component_ptr (i_component)
              if (component%i_mci /= i_mci) cycle
              select case (component%component_type)
              case (COMP_MASTER, COMP_REAL)
                 pcm_instance%i_mci_to_real_component (i_mci) = &
                      component%config%get_associated_real ()
              case (COMP_REAL_FIN)
                 pcm_instance%i_mci_to_real_component (i_mci) = &
                      component%config%get_associated_real_fin ()
              case (COMP_REAL_SING)
                 pcm_instance%i_mci_to_real_component (i_mci) = &
                      component%config%get_associated_real_sing ()
              end select
           end do
        end do
        component => null ()
     end select
   end subroutine process_instance_set_i_mci_to_real_component
 
 @ %def process_instance_set_i_mci_to_real_component
 @ Final step of process evaluation: evaluate the matrix elements, and compute
 the trace (summed over quantum numbers) for all terms.  Finally, sum up the
 terms, iterating over all active process components.
 
 If [[weight]] is provided, we already know the kinematical event
 weight (the MCI weight which depends on the kinematics sampling
 algorithm, but not on the matrix element), so we do not need to take
 it from the MCI record.
 <<Instances: process instance: TBP>>=
   procedure :: evaluate_event_data => process_instance_evaluate_event_data
 <<Instances: procedures>>=
   subroutine process_instance_evaluate_event_data (instance, weight)
     class(process_instance_t), intent(inout) :: instance
     real(default), intent(in), optional :: weight
     integer :: i
     if (instance%evaluation_status >= STAT_EVALUATED_TRACE) then
        do i = 1, size (instance%term)
           associate (term => instance%term(i))
             if (term%active .and. term%passed) then
                call term%evaluate_event_data ()
             end if
           end associate
        end do
        if (present (weight)) then
           instance%weight = weight
        else
           instance%weight = &
                instance%mci_work(instance%i_mci)%mci%get_event_weight ()
           instance%excess = &
                instance%mci_work(instance%i_mci)%mci%get_event_excess ()
        end if
        instance%evaluation_status = STAT_EVENT_COMPLETE
     else
        !!! failed kinematics etc.: set weight to zero
        instance%weight = zero
        !!! Maybe we want to keep the event nevertheless
        if (instance%keep_failed_events ()) then
           !!! Force factorization scale, otherwise writing to event output fails
           do i = 1, size (instance%term)
              instance%term(i)%fac_scale = zero
           end do
           instance%evaluation_status = STAT_EVENT_COMPLETE
        end if
     end if
   end subroutine process_instance_evaluate_event_data
 
 @ %def process_instance_evaluate_event_data
 @ Computes the real-emission matrix element for externally supplied momenta. Also,
 e.g. for Powheg, there is the possibility to supply an external $\alpha_s$
 <<Instances: process instance: TBP>>=
   procedure :: compute_sqme_rad => process_instance_compute_sqme_rad
 <<Instances: procedures>>=
   subroutine process_instance_compute_sqme_rad &
          (instance, i_term, i_phs, is_subtraction, alpha_s_external)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_term, i_phs
     logical, intent(in) :: is_subtraction
     real(default), intent(in), optional :: alpha_s_external
     class(prc_core_t), pointer :: core
     integer :: i_real_fin
     call msg_debug2 (D_PROCESS_INTEGRATION, "process_instance_compute_sqme_rad")
     select type (pcm => instance%pcm)
     type is (pcm_instance_nlo_t)
        associate (term => instance%term(i_term))
           core => instance%process%get_core_term (i_term)
           if (is_subtraction) then
              call pcm%set_subtraction_event ()
           else
              call pcm%set_radiation_event ()
           end if
           call term%int_hard%set_momenta (pcm%get_momenta &
                (i_phs = i_phs, born_phsp = is_subtraction))
           if (allocated (term%core_state)) &
                call term%core_state%reset_new_kinematics ()
           if (present (alpha_s_external)) &
                call term%set_alpha_qcd_forced (alpha_s_external)
           call term%compute_eff_kinematics ()
           call term%evaluate_expressions ()
           call term%evaluate_interaction (core)
           call term%evaluate_trace ()
           pcm%real_sub%sqme_born (1) = &
                real (term%connected%trace%get_matrix_element (1))
           if (term%is_subtraction ()) then
              select type (config => term%pcm_instance%config)
              type is (pcm_nlo_t)
                 if (char (config%settings%nlo_correction_type) == "QCD" .or. &
                      char (config%settings%nlo_correction_type) == "Full") &
                      call term%evaluate_color_correlations (core)
                 if (char (config%settings%nlo_correction_type) == "QED" .or. &
                      char (config%settings%nlo_correction_type) == "Full") &
                      call term%evaluate_charge_correlations (core)
              end select
              call term%evaluate_spin_correlations (core)
              if (term%pcm_instance%config%has_pdfs) &
                   call term%compute_sqme_coll_isr ()
           else if (term%nlo_type == NLO_DGLAP) then
              call term%compute_sqme_coll_isr ()
           end if
           i_real_fin = instance%process%get_associated_real_fin (1)
           if (term%config%i_component /= i_real_fin) &
                call term%apply_fks (core%get_alpha_s (term%core_state), 0._default)
           if (instance%process%uses_real_partition ()) &
                call instance%apply_real_partition ()
        end associate
     end select
     core => null ()
   end subroutine process_instance_compute_sqme_rad
 
 @ %def process_instance_compute_sqme_rad
 @ For unweighted event generation, we should reset the reported event
 weight to unity (signed) or zero.  The latter case is appropriate for
 an event which failed for whatever reason.
 <<Instances: process instance: TBP>>=
   procedure :: normalize_weight => process_instance_normalize_weight
 <<Instances: procedures>>=
   subroutine process_instance_normalize_weight (instance)
     class(process_instance_t), intent(inout) :: instance
     if (.not. vanishes (instance%weight)) then
        instance%weight = sign (1._default, instance%weight)
     end if
   end subroutine process_instance_normalize_weight
 
 @ %def process_instance_normalize_weight
 @ This is a convenience routine that performs the computations of the
 steps 1 to 5 in a single step.  The arguments are the input for
 [[set_mcpar]].  After this, the evaluation status should be either
 [[STAT_FAILED_KINEMATICS]], [[STAT_FAILED_CUTS]] or [[STAT_EVALUATED_TRACE]].
 
 Before calling this, we should call [[choose_mci]].
 <<Instances: process instance: TBP>>=
   procedure :: evaluate_sqme => process_instance_evaluate_sqme
 <<Instances: procedures>>=
   subroutine process_instance_evaluate_sqme (instance, channel, x)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: channel
     real(default), dimension(:), intent(in) :: x
     call instance%reset ()
     call instance%set_mcpar (x)
     call instance%select_channel (channel)
     call instance%compute_seed_kinematics ()
     call instance%compute_hard_kinematics ()
     call instance%compute_eff_kinematics ()
     call instance%evaluate_expressions ()
     call instance%compute_other_channels ()
     call instance%evaluate_trace ()
   end subroutine process_instance_evaluate_sqme
 
 @ %def process_instance_evaluate_sqme
 @ This is the inverse.  Assuming that the final trace evaluator
 contains a valid momentum configuration, recover kinematics
 and recalculate the matrix elements and their trace.
 
 To be precise, we first recover kinematics for the given term and
 associated component, then recalculate from that all other terms and
 active components.  The [[channel]] is not really required to obtain
 the matrix element, but it allows us to reconstruct the exact MC
 parameter set that corresponds to the given phase space point.
 
 Before calling this, we should call [[choose_mci]].
 <<Instances: process instance: TBP>>=
   procedure :: recover => process_instance_recover
 <<Instances: procedures>>=
   subroutine process_instance_recover &
        (instance, channel, i_term, update_sqme, recover_phs, scale_forced)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: channel
     integer, intent(in) :: i_term
     logical, intent(in) :: update_sqme
     logical, intent(in) :: recover_phs
     real(default), intent(in), allocatable, optional :: scale_forced
     logical :: skip_phs
     call instance%activate ()
     instance%evaluation_status = STAT_EFF_KINEMATICS
     call instance%recover_hard_kinematics (i_term)
     call instance%recover_seed_kinematics (i_term)
     call instance%select_channel (channel)
     if (recover_phs) then
        call instance%recover_mcpar (i_term)
        call instance%recover_beam_momenta (i_term)
        call instance%compute_seed_kinematics (i_term)
        call instance%compute_hard_kinematics (i_term)
        call instance%compute_eff_kinematics (i_term)
        call instance%compute_other_channels (i_term)
     else
        call instance%recover_sfchain (i_term)
     end if
     call instance%evaluate_expressions (scale_forced)
     if (update_sqme) then
        call instance%reset_core_kinematics ()
        call instance%evaluate_trace ()
     end if
   end subroutine process_instance_recover
 
 @ %def process_instance_recover
 @ The [[evaluate]] method is required by the [[sampler_t]] base type of which
 the process instance is an extension.
 
 The requirement is that after the process instance is evaluated, the
 integrand, the selected channel, the $x$ array, and the $f$ Jacobian array are
 exposed by the [[sampler_t]] object.
 
 We allow for the additional [[hook]] to be called, if associated, for outlying
 object to access information from the current state of the [[sampler]].
 <<Instances: process instance: TBP>>=
   procedure :: evaluate => process_instance_evaluate
 <<Instances: procedures>>=
   subroutine process_instance_evaluate (sampler, c, x_in, val, x, f)
     class(process_instance_t), intent(inout) :: sampler
     integer, intent(in) :: c
     real(default), dimension(:), intent(in) :: x_in
     real(default), intent(out) :: val
     real(default), dimension(:,:), intent(out) :: x
     real(default), dimension(:), intent(out) :: f
     call sampler%evaluate_sqme (c, x_in)
     if (sampler%is_valid ()) then
        call sampler%fetch (val, x, f)
     end if
     call sampler%record_call ()
     call sampler%evaluate_after_hook ()
   end subroutine process_instance_evaluate
 
 @ %def process_instance_evaluate
 @ The phase-space point is valid if the event has valid kinematics and
 has passed the cuts.
 <<Instances: process instance: TBP>>=
   procedure :: is_valid => process_instance_is_valid
 <<Instances: procedures>>=
   function process_instance_is_valid (sampler) result (valid)
     class(process_instance_t), intent(in) :: sampler
     logical :: valid
     valid = sampler%evaluation_status >= STAT_PASSED_CUTS
   end function process_instance_is_valid
 
 @ %def process_instance_is_valid
 @ Add a [[process_instance_hook]] object..
 <<Instances: process instance: TBP>>=
   procedure :: append_after_hook => process_instance_append_after_hook
 <<Instances: procedures>>=
   subroutine process_instance_append_after_hook (sampler, new_hook)
     class(process_instance_t), intent(inout), target :: sampler
     class(process_instance_hook_t), intent(inout), target :: new_hook
     class(process_instance_hook_t), pointer :: last
     if (associated (new_hook%next)) then
        call msg_bug ("process_instance_append_after_hook: reuse of SAME hook object is forbidden.")
     end if
     if (associated (sampler%hook)) then
        last => sampler%hook
        do while (associated (last%next))
           last => last%next
        end do
        last%next => new_hook
     else
        sampler%hook => new_hook
     end if
   end subroutine process_instance_append_after_hook
 
 @ %def process_instance_append_after_evaluate_hook
 @ Evaluate the after hook as first in, last out.
 <<Instances: process instance: TBP>>=
   procedure :: evaluate_after_hook => process_instance_evaluate_after_hook
 <<Instances: procedures>>=
   subroutine process_instance_evaluate_after_hook (sampler)
     class(process_instance_t), intent(in) :: sampler
     class(process_instance_hook_t), pointer :: current
     current => sampler%hook
     do while (associated(current))
        call current%evaluate (sampler)
        current => current%next
     end do
   end subroutine process_instance_evaluate_after_hook
 
 @ %def process_instance_evaluate_after_hook
 @ The [[rebuild]] method should rebuild the kinematics section out of
 the [[x_in]] parameter set.  The integrand value [[val]] should not be
 computed, but is provided as input.
 <<Instances: process instance: TBP>>=
   procedure :: rebuild => process_instance_rebuild
 <<Instances: procedures>>=
   subroutine process_instance_rebuild (sampler, c, x_in, val, x, f)
     class(process_instance_t), intent(inout) :: sampler
     integer, intent(in) :: c
     real(default), dimension(:), intent(in) :: x_in
     real(default), intent(in) :: val
     real(default), dimension(:,:), intent(out) :: x
     real(default), dimension(:), intent(out) :: f
     call msg_bug ("process_instance_rebuild not implemented yet")
     x = 0
     f = 0
   end subroutine process_instance_rebuild
 
 @ %def process_instance_rebuild
 @ This is another method required by the [[sampler_t]] base type:
 fetch the data that are relevant for the MCI record.
 <<Instances: process instance: TBP>>=
   procedure :: fetch => process_instance_fetch
 <<Instances: procedures>>=
   subroutine process_instance_fetch (sampler, val, x, f)
     class(process_instance_t), intent(in) :: sampler
     real(default), intent(out) :: val
     real(default), dimension(:,:), intent(out) :: x
     real(default), dimension(:), intent(out) :: f
     integer, dimension(:), allocatable :: i_terms
     integer :: i, i_term_base, cc
     integer :: n_channel
 
     val = 0
     associate (process => sampler%process)
        FIND_COMPONENT: do i = 1, process%get_n_components ()
          if (sampler%process%component_is_selected (i)) then
             allocate (i_terms (size (process%get_component_i_terms (i))))
             i_terms = process%get_component_i_terms (i)
             i_term_base = i_terms(1)
             associate (k => sampler%term(i_term_base)%k_term)
               n_channel = k%n_channel
               do cc = 1, n_channel
                  call k%get_mcpar (cc, x(:,cc))
               end do
               f = k%f
               val = sampler%sqme * k%phs_factor
             end associate
             if (allocated (i_terms)) deallocate (i_terms)
             exit FIND_COMPONENT
          end if
        end do FIND_COMPONENT
     end associate
   end subroutine process_instance_fetch
 
 @ %def process_instance_fetch
 @ Initialize and finalize event generation for the specified MCI
 entry.
 <<Instances: process instance: TBP>>=
   procedure :: init_simulation => process_instance_init_simulation
   procedure :: final_simulation => process_instance_final_simulation
 <<Instances: procedures>>=
   subroutine process_instance_init_simulation (instance, i_mci, &
      safety_factor, keep_failed_events)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_mci
     real(default), intent(in), optional :: safety_factor
     logical, intent(in), optional :: keep_failed_events
     call instance%mci_work(i_mci)%init_simulation (safety_factor, keep_failed_events)
   end subroutine process_instance_init_simulation
 
   subroutine process_instance_final_simulation (instance, i_mci)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_mci
     call instance%mci_work(i_mci)%final_simulation ()
   end subroutine process_instance_final_simulation
 
 @ %def process_instance_init_simulation
 @ %def process_instance_final_simulation
 @
 \subsubsection{Accessing the process instance}
 Once the seed kinematics is complete, we can retrieve the MC input parameters
 for all channels, not just the seed channel.
 
 Note: We choose the first active component.  This makes sense only if the seed
 kinematics is identical for all active components.
 <<Instances: process instance: TBP>>=
   procedure :: get_mcpar => process_instance_get_mcpar
 <<Instances: procedures>>=
   subroutine process_instance_get_mcpar (instance, channel, x)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: channel
     real(default), dimension(:), intent(out) :: x
     integer :: i
     if (instance%evaluation_status >= STAT_SEED_KINEMATICS) then
        do i = 1, size (instance%term)
           if (instance%term(i)%active) then
              call instance%term(i)%k_term%get_mcpar (channel, x)
              return
           end if
        end do
        call msg_bug ("Process instance: get_mcpar: no active channels")
     else
        call msg_bug ("Process instance: get_mcpar: no seed kinematics")
     end if
   end subroutine process_instance_get_mcpar
 
 @ %def process_instance_get_mcpar
 @ Return true if the [[sqme]] value is known.  This also implies that the
 event is kinematically valid and has passed all cuts.
 <<Instances: process instance: TBP>>=
   procedure :: has_evaluated_trace => process_instance_has_evaluated_trace
 <<Instances: procedures>>=
   function process_instance_has_evaluated_trace (instance) result (flag)
     class(process_instance_t), intent(in) :: instance
     logical :: flag
     flag = instance%evaluation_status >= STAT_EVALUATED_TRACE
   end function process_instance_has_evaluated_trace
 
 @ %def process_instance_has_evaluated_trace
 @ Return true if the event is complete.  In particular, the event must
 be kinematically valid, passed all cuts, and the event data have been
 computed.
 <<Instances: process instance: TBP>>=
   procedure :: is_complete_event => process_instance_is_complete_event
 <<Instances: procedures>>=
   function process_instance_is_complete_event (instance) result (flag)
     class(process_instance_t), intent(in) :: instance
     logical :: flag
     flag = instance%evaluation_status >= STAT_EVENT_COMPLETE
   end function process_instance_is_complete_event
 
 @ %def process_instance_is_complete_event
 @ Select the term for the process instance that will provide the basic
 event record (used in [[evt_trivial_make_particle_set]]).  It might be
 necessary to write out additional events corresponding to other terms
 (done in [[evt_nlo]]).
 <<Instances: process instance: TBP>>=
   procedure :: select_i_term => process_instance_select_i_term
 <<Instances: procedures>>=
   function process_instance_select_i_term (instance) result (i_term)
     integer :: i_term
     class(process_instance_t), intent(in) :: instance
     integer :: i_mci
     i_mci = instance%i_mci
     i_term = instance%process%select_i_term (i_mci)
   end function process_instance_select_i_term
 
 @ %def process_instance_select_i_term
 @ Return pointer to the master beam interaction.
 <<Instances: process instance: TBP>>=
   procedure :: get_beam_int_ptr => process_instance_get_beam_int_ptr
 <<Instances: procedures>>=
   function process_instance_get_beam_int_ptr (instance) result (ptr)
     class(process_instance_t), intent(in), target :: instance
     type(interaction_t), pointer :: ptr
     ptr => instance%sf_chain%get_beam_int_ptr ()
   end function process_instance_get_beam_int_ptr
 
 @ %def process_instance_get_beam_int_ptr
 @ Return pointers to the matrix and flows interactions, given a term index.
 <<Instances: process instance: TBP>>=
   procedure :: get_trace_int_ptr => process_instance_get_trace_int_ptr
   procedure :: get_matrix_int_ptr => process_instance_get_matrix_int_ptr
   procedure :: get_flows_int_ptr => process_instance_get_flows_int_ptr
 <<Instances: procedures>>=
   function process_instance_get_trace_int_ptr (instance, i_term) result (ptr)
     class(process_instance_t), intent(in), target :: instance
     integer, intent(in) :: i_term
     type(interaction_t), pointer :: ptr
     ptr => instance%term(i_term)%connected%get_trace_int_ptr ()
   end function process_instance_get_trace_int_ptr
 
   function process_instance_get_matrix_int_ptr (instance, i_term) result (ptr)
     class(process_instance_t), intent(in), target :: instance
     integer, intent(in) :: i_term
     type(interaction_t), pointer :: ptr
     ptr => instance%term(i_term)%connected%get_matrix_int_ptr ()
   end function process_instance_get_matrix_int_ptr
 
   function process_instance_get_flows_int_ptr (instance, i_term) result (ptr)
     class(process_instance_t), intent(in), target :: instance
     integer, intent(in) :: i_term
     type(interaction_t), pointer :: ptr
     ptr => instance%term(i_term)%connected%get_flows_int_ptr ()
   end function process_instance_get_flows_int_ptr
 
 @ %def process_instance_get_trace_int_ptr
 @ %def process_instance_get_matrix_int_ptr
 @ %def process_instance_get_flows_int_ptr
 @ Return the complete account of flavor combinations in the underlying
 interaction object, including beams, radiation, and hard interaction.
 <<Instances: process instance: TBP>>=
   procedure :: get_state_flv => process_instance_get_state_flv
 <<Instances: procedures>>=
   function process_instance_get_state_flv (instance, i_term) result (state_flv)
     class(process_instance_t), intent(in) :: instance
     integer, intent(in) :: i_term
     type(state_flv_content_t) :: state_flv
     state_flv = instance%term(i_term)%connected%get_state_flv ()
   end function process_instance_get_state_flv
 
 @ %def process_instance_get_state_flv
 @ Return pointers to the parton states of a selected term.
 <<Instances: process instance: TBP>>=
   procedure :: get_isolated_state_ptr => &
        process_instance_get_isolated_state_ptr
   procedure :: get_connected_state_ptr => &
        process_instance_get_connected_state_ptr
 <<Instances: procedures>>=
   function process_instance_get_isolated_state_ptr (instance, i_term) &
        result (ptr)
     class(process_instance_t), intent(in), target :: instance
     integer, intent(in) :: i_term
     type(isolated_state_t), pointer :: ptr
     ptr => instance%term(i_term)%isolated
   end function process_instance_get_isolated_state_ptr
 
   function process_instance_get_connected_state_ptr (instance, i_term) &
        result (ptr)
     class(process_instance_t), intent(in), target :: instance
     integer, intent(in) :: i_term
     type(connected_state_t), pointer :: ptr
     ptr => instance%term(i_term)%connected
   end function process_instance_get_connected_state_ptr
 
 @ %def process_instance_get_isolated_state_ptr
 @ %def process_instance_get_connected_state_ptr
 @ Return the indices of the beam particles and incoming partons within the
 currently active state matrix, respectively.
 <<Instances: process instance: TBP>>=
   procedure :: get_beam_index => process_instance_get_beam_index
   procedure :: get_in_index => process_instance_get_in_index
 <<Instances: procedures>>=
   subroutine process_instance_get_beam_index (instance, i_term, i_beam)
     class(process_instance_t), intent(in) :: instance
     integer, intent(in) :: i_term
     integer, dimension(:), intent(out) :: i_beam
     call instance%term(i_term)%connected%get_beam_index (i_beam)
   end subroutine process_instance_get_beam_index
 
   subroutine process_instance_get_in_index (instance, i_term, i_in)
     class(process_instance_t), intent(in) :: instance
     integer, intent(in) :: i_term
     integer, dimension(:), intent(out) :: i_in
     call instance%term(i_term)%connected%get_in_index (i_in)
   end subroutine process_instance_get_in_index
 
 @ %def process_instance_get_beam_index
 @ %def process_instance_get_in_index
 @ Return squared matrix element and event weight, and event weight
 excess where applicable.
 <<Instances: process instance: TBP>>=
   procedure :: get_sqme => process_instance_get_sqme
   procedure :: get_weight => process_instance_get_weight
   procedure :: get_excess => process_instance_get_excess
 <<Instances: procedures>>=
   function process_instance_get_sqme (instance, i_term) result (sqme)
     real(default) :: sqme
     class(process_instance_t), intent(in) :: instance
     integer, intent(in), optional :: i_term
     if (instance%evaluation_status >= STAT_EVALUATED_TRACE) then
        if (present (i_term)) then
           sqme = instance%term(i_term)%connected%trace%get_matrix_element (1)
        else
           sqme = instance%sqme
        end if
     else
        sqme = 0
     end if
   end function process_instance_get_sqme
 
   function process_instance_get_weight (instance) result (weight)
     real(default) :: weight
     class(process_instance_t), intent(in) :: instance
     if (instance%evaluation_status >= STAT_EVENT_COMPLETE) then
        weight = instance%weight
     else
        weight = 0
     end if
   end function process_instance_get_weight
 
   function process_instance_get_excess (instance) result (excess)
     real(default) :: excess
     class(process_instance_t), intent(in) :: instance
     if (instance%evaluation_status >= STAT_EVENT_COMPLETE) then
        excess = instance%excess
     else
        excess = 0
     end if
   end function process_instance_get_excess
 
 @ %def process_instance_get_sqme
 @ %def process_instance_get_weight
 @ %def process_instance_get_excess
 @ Return the currently selected MCI channel.
 <<Instances: process instance: TBP>>=
   procedure :: get_channel => process_instance_get_channel
 <<Instances: procedures>>=
   function process_instance_get_channel (instance) result (channel)
     integer :: channel
     class(process_instance_t), intent(in) :: instance
     channel = instance%selected_channel
   end function process_instance_get_channel
 
 @ %def process_instance_get_channel
 @
 <<Instances: process instance: TBP>>=
   procedure :: set_fac_scale => process_instance_set_fac_scale
 <<Instances: procedures>>=
   subroutine process_instance_set_fac_scale (instance, fac_scale)
     class(process_instance_t), intent(inout) :: instance
     real(default), intent(in) :: fac_scale
     integer :: i_term
     i_term = 1
     call instance%term(i_term)%set_fac_scale (fac_scale)
   end subroutine process_instance_set_fac_scale
 
 @ %def process_instance_set_fac_scale
 @ Return factorization scale and strong coupling.  We have to select a
 term instance.
 <<Instances: process instance: TBP>>=
   procedure :: get_fac_scale => process_instance_get_fac_scale
   procedure :: get_alpha_s => process_instance_get_alpha_s
 <<Instances: procedures>>=
   function process_instance_get_fac_scale (instance, i_term) result (fac_scale)
     class(process_instance_t), intent(in) :: instance
     integer, intent(in) :: i_term
     real(default) :: fac_scale
     fac_scale = instance%term(i_term)%get_fac_scale ()
   end function process_instance_get_fac_scale
 
   function process_instance_get_alpha_s (instance, i_term) result (alpha_s)
     real(default) :: alpha_s
     class(process_instance_t), intent(in) :: instance
     integer, intent(in) :: i_term
     class(prc_core_t), pointer :: core => null ()
     core => instance%process%get_core_term (i_term)
     alpha_s = instance%term(i_term)%get_alpha_s (core)
     core => null ()
   end function process_instance_get_alpha_s
 
 @ %def process_instance_get_fac_scale
 @ %def process_instance_get_alpha_s
 @
 <<Instances: process instance: TBP>>=
   procedure :: get_qcd_ptr => process_instance_get_qcd_ptr
 <<Instances: procedures>>=
   function process_instance_get_qcd_ptr (process_instance) result (qcd)
     type(qcd_t), pointer :: qcd
     class(process_instance_t), intent(in), target :: process_instance
     qcd => process_instance%process%get_qcd_ptr ()
   end function process_instance_get_qcd_ptr
 
 @ %def process_instance_get_qcd_ptr
 @ Counter.
 <<Instances: process instance: TBP>>=
   procedure :: reset_counter => process_instance_reset_counter
   procedure :: record_call => process_instance_record_call
   procedure :: get_counter => process_instance_get_counter
 <<Instances: procedures>>=
   subroutine process_instance_reset_counter (process_instance)
     class(process_instance_t), intent(inout) :: process_instance
     call process_instance%mci_work(process_instance%i_mci)%reset_counter ()
   end subroutine process_instance_reset_counter
 
   subroutine process_instance_record_call (process_instance)
     class(process_instance_t), intent(inout) :: process_instance
     call process_instance%mci_work(process_instance%i_mci)%record_call &
          (process_instance%evaluation_status)
   end subroutine process_instance_record_call
 
   pure function process_instance_get_counter (process_instance) result (counter)
     class(process_instance_t), intent(in) :: process_instance
     type(process_counter_t) :: counter
     counter = process_instance%mci_work(process_instance%i_mci)%get_counter ()
   end function process_instance_get_counter
 
 @ %def process_instance_reset_counter
 @ %def process_instance_record_call
 @ %def process_instance_get_counter
 @ Sum up the total number of calls for all MCI records.
 <<Instances: process instance: TBP>>=
   procedure :: get_actual_calls_total => process_instance_get_actual_calls_total
 <<Instances: procedures>>=
   pure function process_instance_get_actual_calls_total (process_instance) &
        result (n)
     class(process_instance_t), intent(in) :: process_instance
     integer :: n
     integer :: i
     type(process_counter_t) :: counter
     n = 0
     do i = 1, size (process_instance%mci_work)
        counter = process_instance%mci_work(i)%get_counter ()
        n = n + counter%total
     end do
   end function process_instance_get_actual_calls_total
 
 @ %def process_instance_get_actual_calls_total
 @
 <<Instances: process instance: TBP>>=
   procedure :: reset_matrix_elements => process_instance_reset_matrix_elements
 <<Instances: procedures>>=
   subroutine process_instance_reset_matrix_elements (instance)
     class(process_instance_t), intent(inout) :: instance
     integer :: i_term
     do i_term = 1, size (instance%term)
        call instance%term(i_term)%connected%trace%set_matrix_element (cmplx (0, 0, default))
        call instance%term(i_term)%connected%matrix%set_matrix_element (cmplx (0, 0, default))
     end do
   end subroutine process_instance_reset_matrix_elements
 
 @ %def process_instance_reset_matrix_elements
 @
 <<Instances: process instance: TBP>>=
   procedure :: get_test_phase_space_point &
      => process_instance_get_test_phase_space_point
 <<Instances: procedures>>=
   subroutine process_instance_get_test_phase_space_point (instance, &
          i_component, i_core, p)
     type(vector4_t), dimension(:), allocatable, intent(out) :: p
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_component, i_core
     real(default), dimension(:), allocatable :: x
     logical :: success
     integer :: i_term
     instance%i_mci = i_component
     i_term = instance%process%get_i_term (i_core)
     associate (term => instance%term(i_term))
        allocate (x (instance%mci_work(i_component)%config%n_par))
        x = 0.5_default
        call instance%set_mcpar (x, .true.)
        call instance%select_channel (1)
        call term%compute_seed_kinematics &
             (instance%mci_work(i_component), 1, success)
        call instance%term(i_term)%evaluate_radiation_kinematics &
               (instance%mci_work(instance%i_mci)%get_x_process ())
        call instance%term(i_term)%compute_hard_kinematics (success = success)
        allocate (p (size (term%p_hard)))
        p = term%int_hard%get_momenta ()
     end associate
   end subroutine process_instance_get_test_phase_space_point
 
 @ %def process_instance_get_test_phase_space_point
 @
 <<Instances: process instance: TBP>>=
   procedure :: get_p_hard => process_instance_get_p_hard
 <<Instances: procedures>>=
   pure function process_instance_get_p_hard (process_instance, i_term) &
          result (p_hard)
     type(vector4_t), dimension(:), allocatable :: p_hard
     class(process_instance_t), intent(in) :: process_instance
     integer, intent(in) :: i_term
     allocate (p_hard (size (process_instance%term(i_term)%get_p_hard ())))
     p_hard = process_instance%term(i_term)%get_p_hard ()
   end function process_instance_get_p_hard
 
 @ %def process_instance_get_p_hard
 @
 <<Instances: process instance: TBP>>=
   procedure :: get_first_active_i_term => process_instance_get_first_active_i_term
 <<Instances: procedures>>=
   function process_instance_get_first_active_i_term (instance) result (i_term)
     integer :: i_term
     class(process_instance_t), intent(in) :: instance
     integer :: i
     i_term = 0
     do i = 1, size (instance%term)
        if (instance%term(i)%active) then
           i_term = i
           exit
        end if
     end do
   end function process_instance_get_first_active_i_term
 
 @ %def process_instance_get_first_active_i_term
 @
 <<Instances: process instance: TBP>>=
   procedure :: get_real_of_mci => process_instance_get_real_of_mci
 <<Instances: procedures>>=
   function process_instance_get_real_of_mci (instance) result (i_real)
     integer :: i_real
     class(process_instance_t), intent(in) :: instance
     select type (pcm => instance%pcm)
     type is (pcm_instance_nlo_t)
        i_real = pcm%i_mci_to_real_component (instance%i_mci)
     end select
   end function process_instance_get_real_of_mci
 
 @ %def process_instance_get_real_of_mci
 @
 <<Instances: process instance: TBP>>=
   procedure :: get_connected_states => process_instance_get_connected_states
 <<Instances: procedures>>=
   function process_instance_get_connected_states (instance, i_component) result (connected)
     type(connected_state_t), dimension(:), allocatable :: connected
     class(process_instance_t), intent(in) :: instance
     integer, intent(in) :: i_component
     connected = instance%process%get_connected_states (i_component, &
         instance%term(:)%connected)
   end function process_instance_get_connected_states
 
 @ %def process_instance_get_connected_states
 @ Get the hadronic center-of-mass energy
 <<Instances: process instance: TBP>>=
   procedure :: get_sqrts => process_instance_get_sqrts
 <<Instances: procedures>>=
   function process_instance_get_sqrts (instance) result (sqrts)
     class(process_instance_t), intent(in) :: instance
     real(default) :: sqrts
     sqrts = instance%process%get_sqrts ()
   end function process_instance_get_sqrts
 
 @ %def process_instance_get_sqrts
 @ Get the polarizations
 <<Instances: process instance: TBP>>=
   procedure :: get_polarization => process_instance_get_polarization
 <<Instances: procedures>>=
   function process_instance_get_polarization (instance) result (pol)
     class(process_instance_t), intent(in) :: instance
     real(default), dimension(2) :: pol
     pol = instance%process%get_polarization ()
   end function process_instance_get_polarization
 
 @ %def process_instance_get_polarization
 @ Get the beam spectrum
 <<Instances: process instance: TBP>>=
   procedure :: get_beam_file => process_instance_get_beam_file
 <<Instances: procedures>>=
   function process_instance_get_beam_file (instance) result (file)
     class(process_instance_t), intent(in) :: instance
     type(string_t) :: file
     file = instance%process%get_beam_file ()
   end function process_instance_get_beam_file
 
 @ %def process_instance_get_beam_file
 @ Get the process name
 <<Instances: process instance: TBP>>=
   procedure :: get_process_name => process_instance_get_process_name
 <<Instances: procedures>>=
   function process_instance_get_process_name (instance) result (name)
     class(process_instance_t), intent(in) :: instance
     type(string_t) :: name
     name = instance%process%get_id ()
   end function process_instance_get_process_name
 
 @ %def process_instance_get_process_name
 @
 \subsubsection{Particle sets}
 Here we provide two procedures that convert the process instance
 from/to a particle set.  The conversion applies to the trace evaluator
 which has no quantum-number information, thus it involves only the
 momenta and the parent-child relations.  We keep virtual particles.
 
 If [[n_incoming]] is provided, the status code of the first
 [[n_incoming]] particles will be reset to incoming.  Otherwise, they
 would be classified as virtual.
 
 Nevertheless, it is possible to reconstruct the complete structure
 from a particle set.  The reconstruction implies a re-evaluation of
 the structure function and matrix-element codes.
 
 The [[i_term]] index is needed for both input and output, to select
 among different active trace evaluators.
 
 In both cases, the [[instance]] object must be properly initialized.
 
 NB: The [[recover_beams]] option should be used only when the particle
 set originates from an external event file, and the user has asked for
 it.  It should be switched off when reading from raw event file.
 <<Instances: process instance: TBP>>=
   procedure :: get_trace => process_instance_get_trace
   procedure :: set_trace => process_instance_set_trace
 <<Instances: procedures>>=
   subroutine process_instance_get_trace (instance, pset, i_term, n_incoming)
     class(process_instance_t), intent(in), target :: instance
     type(particle_set_t), intent(out) :: pset
     integer, intent(in) :: i_term
     integer, intent(in), optional :: n_incoming
     type(interaction_t), pointer :: int
     logical :: ok
     int => instance%get_trace_int_ptr (i_term)
     call pset%init (ok, int, int, FM_IGNORE_HELICITY, &
          [0._default, 0._default], .false., .true., n_incoming)
   end subroutine process_instance_get_trace
 
   subroutine process_instance_set_trace &
        (instance, pset, i_term, recover_beams, check_match)
     class(process_instance_t), intent(inout), target :: instance
     type(particle_set_t), intent(in) :: pset
     integer, intent(in) :: i_term
     logical, intent(in), optional :: recover_beams, check_match
     type(interaction_t), pointer :: int
     integer :: n_in
     int => instance%get_trace_int_ptr (i_term)
     n_in = instance%process%get_n_in ()
     call pset%fill_interaction (int, n_in, &
          recover_beams = recover_beams, &
          check_match = check_match, &
          state_flv = instance%get_state_flv (i_term))
   end subroutine process_instance_set_trace
 
 @ %def process_instance_get_trace
 @ %def process_instance_set_trace
 @ This procedure allows us to override any QCD setting of the WHIZARD process
 and directly set the coupling value that comes together with a particle set.
 <<Instances: process instance: TBP>>=
   procedure :: set_alpha_qcd_forced => process_instance_set_alpha_qcd_forced
 <<Instances: procedures>>=
   subroutine process_instance_set_alpha_qcd_forced (instance, i_term, alpha_qcd)
     class(process_instance_t), intent(inout) :: instance
     integer, intent(in) :: i_term
     real(default), intent(in) :: alpha_qcd
     call instance%term(i_term)%set_alpha_qcd_forced (alpha_qcd)
   end subroutine process_instance_set_alpha_qcd_forced
 
 @ %def process_instance_set_alpha_qcd_forced
 @
 <<Instances: process instance: TBP>>=
   procedure :: has_nlo_component => process_instance_has_nlo_component
 <<Instances: procedures>>=
   function process_instance_has_nlo_component (instance) result (nlo)
     class(process_instance_t), intent(in) :: instance
     logical :: nlo
     nlo = instance%process%is_nlo_calculation ()
   end function process_instance_has_nlo_component
 
 @ %def process_instance_has_nlo_component
 @
 <<Instances: process instance: TBP>>=
   procedure :: keep_failed_events => process_instance_keep_failed_events
 <<Instances: procedures>>=
   function process_instance_keep_failed_events (instance) result (keep)
     logical :: keep
     class(process_instance_t), intent(in) :: instance
     keep = instance%mci_work(instance%i_mci)%keep_failed_events
   end function process_instance_keep_failed_events
 
 @ %def process_instance_keep_failed_events
 @
 <<Instances: process instance: TBP>>=
   procedure :: get_term_indices => process_instance_get_term_indices
 <<Instances: procedures>>=
   function process_instance_get_term_indices (instance, nlo_type) result (i_term)
     integer, dimension(:), allocatable :: i_term
     class(process_instance_t), intent(in) :: instance
     integer :: nlo_type
     allocate (i_term (count (instance%term%nlo_type == nlo_type)))
     i_term = pack (instance%term%get_i_term_global (), instance%term%nlo_type == nlo_type)
   end function process_instance_get_term_indices
 
 @ %def process_instance_get_term_indices
 @
 <<Instances: process instance: TBP>>=
   procedure :: get_boost_to_lab => process_instance_get_boost_to_lab
 <<Instances: procedures>>=
   function process_instance_get_boost_to_lab (instance, i_term) result (lt)
     type(lorentz_transformation_t) :: lt
     class(process_instance_t), intent(in) :: instance
     integer, intent(in) :: i_term
     lt = instance%term(i_term)%get_boost_to_lab ()
   end function process_instance_get_boost_to_lab
 
 @ %def process_instance_get_boost_to_lab
 @
 <<Instances: process instance: TBP>>=
   procedure :: get_boost_to_cms => process_instance_get_boost_to_cms
 <<Instances: procedures>>=
   function process_instance_get_boost_to_cms (instance, i_term) result (lt)
     type(lorentz_transformation_t) :: lt
     class(process_instance_t), intent(in) :: instance
     integer, intent(in) :: i_term
     lt = instance%term(i_term)%get_boost_to_cms ()
   end function process_instance_get_boost_to_cms
 
 @ %def process_instance_get_boost_to_cms
 @
 <<Instances: process instance: TBP>>=
   procedure :: is_cm_frame => process_instance_is_cm_frame
 <<Instances: procedures>>=
   function process_instance_is_cm_frame (instance, i_term) result (cm_frame)
     logical :: cm_frame
     class(process_instance_t), intent(in) :: instance
     integer, intent(in) :: i_term
     cm_frame = instance%term(i_term)%k_term%phs%is_cm_frame ()
   end function process_instance_is_cm_frame
 
 @ %def protcess_instance_is_cm_frame
 @
 The [[pacify]] subroutine has the purpose of setting numbers to zero
 which are (by comparing with a [[tolerance]] parameter) considered
 equivalent with zero.  We do this in some unit tests.  Here, we a
 apply this to the phase space subobject of the process instance.
 <<Instances: public>>=
   public :: pacify
 <<Instances: interfaces>>=
   interface pacify
      module procedure pacify_process_instance
   end interface pacify
 
 <<Instances: procedures>>=
   subroutine pacify_process_instance (instance)
     type(process_instance_t), intent(inout) :: instance
     integer :: i
     do i = 1, size (instance%term)
        call pacify (instance%term(i)%k_term%phs)
     end do
   end subroutine pacify_process_instance
 
 @ %def pacify
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[processes_ut.f90]]>>=
 <<File header>>
 
 module processes_ut
   use unit_tests
   use processes_uti
 
 <<Standard module head>>
 
 <<Processes: public test>>
 
 <<Processes: public test auxiliary>>
 
 contains
 
 <<Processes: test driver>>
 
 end module processes_ut
 @ %def processes_ut
 @
 <<[[processes_uti.f90]]>>=
 <<File header>>
 
 module processes_uti
 
 <<Use kinds>>
 <<Use strings>>
   use format_utils, only: write_separator
   use constants, only: TWOPI4
   use physics_defs, only: CONV
   use os_interface
   use sm_qcd
   use lorentz
   use pdg_arrays
   use model_data
   use var_base, only: vars_t
   use variables, only: var_list_t
   use model_testbed, only: prepare_model
   use particle_specifiers, only: new_prt_spec
   use flavors
   use interactions, only: reset_interaction_counter
   use particles
   use rng_base
   use mci_base
   use mci_none, only: mci_none_t
   use mci_midpoint
   use sf_mappings
   use sf_base
   use phs_base
   use phs_single
   use phs_forests, only: syntax_phs_forest_init, syntax_phs_forest_final
   use phs_wood, only: phs_wood_config_t
   use resonances, only: resonance_history_set_t
   use process_constants
   use prc_core_def, only: prc_core_def_t
   use prc_core
   use prc_test, only: prc_test_create_library
   use prc_template_me, only: template_me_def_t
   use process_libraries
   use prc_test_core
 
   use process_counter
   use process_config, only: process_term_t
   use process, only: process_t
   use instances, only: process_instance_t, process_instance_hook_t
 
   use rng_base_ut, only: rng_test_factory_t
   use sf_base_ut, only: sf_test_data_t
   use mci_base_ut, only: mci_test_t
   use phs_base_ut, only: phs_test_config_t
 
 <<Standard module head>>
 
 <<Processes: public test auxiliary>>
 
 <<Processes: test declarations>>
 
 <<Processes: test types>>
 
 contains
 
 <<Processes: tests>>
 
 <<Processes: test auxiliary>>
 
 end module processes_uti
 
 @ %def processes_uti
 @ API: driver for the unit tests below.
 <<Processes: public test>>=
   public :: processes_test
 <<Processes: test driver>>=
   subroutine processes_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Processes: execute tests>>
   end subroutine processes_test
 
 @ %def processes_test
 \subsubsection{Write an empty process object}
 The most trivial test is to write an uninitialized process object.
 <<Processes: execute tests>>=
   call test (processes_1, "processes_1", &
        "write an empty process object", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_1
 <<Processes: tests>>=
   subroutine processes_1 (u)
     integer, intent(in) :: u
     type(process_t) :: process
 
     write (u, "(A)")  "* Test output: processes_1"
     write (u, "(A)")  "*   Purpose: display an empty process object"
     write (u, "(A)")
 
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_1"
 
   end subroutine processes_1
 
 @ %def processes_1
 @
 \subsubsection{Initialize a process object}
 Initialize a process and display it.
 <<Processes: execute tests>>=
   call test (processes_2, "processes_2", &
        "initialize a simple process object", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_2
 <<Processes: tests>>=
   subroutine processes_2 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable :: process
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
 
     write (u, "(A)")  "* Test output: processes_2"
     write (u, "(A)")  "*   Purpose: initialize a simple process object"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and load a test library with one process"
     write (u, "(A)")
 
     libname = "processes2"
     procname = libname
     run_id = "run2"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib)
 
     write (u, "(A)")  "* Initialize a process object"
     write (u, "(A)")
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
     call process%setup_test_cores ()
 
     allocate (phs_test_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     call process%setup_mci ()
 
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call process%final ()
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_2"
 
   end subroutine processes_2
 
 @ %def processes_2
 @
 \subsubsection{Compute a trivial matrix element}
 Initialize a process, retrieve some information and compute a matrix
 element.
 
 We use the same trivial process as for the previous test.  All
 momentum and state dependence is trivial, so we just test basic
 functionality.
 <<Processes: execute tests>>=
   call test (processes_3, "processes_3", &
        "retrieve a trivial matrix element", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_3
 <<Processes: tests>>=
   subroutine processes_3 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable :: process
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     type(process_constants_t) :: data
     type(vector4_t), dimension(:), allocatable :: p
 
     write (u, "(A)")  "* Test output: processes_3"
     write (u, "(A)")  "*   Purpose: create a process &
          &and compute a matrix element"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and load a test library with one process"
     write (u, "(A)")
 
     libname = "processes3"
     procname = libname
     run_id = "run3"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib)
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
     call process%setup_test_cores ()
 
     allocate (mci_test_t :: mci_template)
     select type (mci_template)
     type is (mci_test_t)
        call mci_template%set_dimensions (2, 2)
        call mci_template%set_divisions (100)
     end select
     allocate (phs_test_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     write (u, "(A)")  "* Return the number of process components"
     write (u, "(A)")
 
     write (u, "(A,I0)")  "n_components = ", process%get_n_components ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Return the number of flavor states"
     write (u, "(A)")
 
     data = process%get_constants (1)
 
     write (u, "(A,I0)")  "n_flv(1) = ", data%n_flv
 
     write (u, "(A)")
     write (u, "(A)")  "* Return the first flavor state"
     write (u, "(A)")
 
     write (u, "(A,4(1x,I0))")  "flv_state(1) =", data%flv_state (:,1)
 
     write (u, "(A)")
     write (u, "(A)")  "* Set up kinematics &
          &[arbitrary, the matrix element is constant]"
 
     allocate (p (4))
 
     write (u, "(A)")
     write (u, "(A)")  "* Retrieve the matrix element"
     write (u, "(A)")
 
 
     write (u, "(A,F5.3,' + ',F5.3,' I')")  "me (1, p, 1, 1, 1) = ", &
          process%compute_amplitude (1, 1, 1, p, 1, 1, 1)
 
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call process%final ()
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_3"
 
   end subroutine processes_3
 
 @ %def processes_3
 @
 \subsubsection{Generate a process instance}
 Initialize a process and process instance, choose a sampling point and
 fill the process instance.
 
 We use the same trivial process as for the previous test.  All
 momentum and state dependence is trivial, so we just test basic
 functionality.
 <<Processes: execute tests>>=
   call test (processes_4, "processes_4", &
        "create and fill a process instance (partonic event)", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_4
 <<Processes: tests>>=
   subroutine processes_4 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable, target :: process
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     real(default) :: sqrts
     type(process_instance_t), allocatable, target :: process_instance
     type(particle_set_t) :: pset
 
     write (u, "(A)")  "* Test output: processes_4"
     write (u, "(A)")  "*   Purpose: create a process &
          &and fill a process instance"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and initialize a test process"
     write (u, "(A)")
 
     libname = "processes4"
     procname = libname
     run_id = "run4"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib)
 
     call reset_interaction_counter ()
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
 
     call process%setup_test_cores ()
     allocate (phs_test_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     write (u, "(A)")  "* Prepare a trivial beam setup"
     write (u, "(A)")
 
     sqrts = 1000
     call process%setup_beams_sqrts (sqrts, i_core = 1)
     call process%configure_phs ()
     call process%setup_mci ()
 
     write (u, "(A)")  "* Complete process initialization"
     write (u, "(A)")
 
     call process%setup_terms ()
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Create a process instance"
     write (u, "(A)")
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Inject a set of random numbers"
     write (u, "(A)")
 
     call process_instance%choose_mci (1)
     call process_instance%set_mcpar ([0._default, 0._default])
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Set up hard kinematics"
     write (u, "(A)")
 
     call process_instance%select_channel (1)
     call process_instance%compute_seed_kinematics ()
     call process_instance%compute_hard_kinematics ()
     call process_instance%compute_eff_kinematics ()
     call process_instance%evaluate_expressions ()
     call process_instance%compute_other_channels ()
 
     write (u, "(A)")  "* Evaluate matrix element and square"
     write (u, "(A)")
 
     call process_instance%evaluate_trace ()
     call process_instance%write (u)
 
     call process_instance%get_trace (pset, 1)
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Particle content:"
     write (u, "(A)")
 
     call write_separator (u)
     call pset%write (u)
     call write_separator (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Recover process instance"
     write (u, "(A)")
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%choose_mci (1)
     call process_instance%set_trace (pset, 1, check_match = .false.)
 
     call process_instance%activate ()
     process_instance%evaluation_status = STAT_EFF_KINEMATICS
     call process_instance%recover_hard_kinematics (i_term = 1)
     call process_instance%recover_seed_kinematics (i_term = 1)
     call process_instance%select_channel (1)
     call process_instance%recover_mcpar (i_term = 1)
 
     call process_instance%compute_seed_kinematics (skip_term = 1)
     call process_instance%compute_hard_kinematics (skip_term = 1)
     call process_instance%compute_eff_kinematics (skip_term = 1)
 
     call process_instance%evaluate_expressions ()
     call process_instance%compute_other_channels (skip_term = 1)
     call process_instance%evaluate_trace ()
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call pset%final ()
     call process_instance%final ()
     deallocate (process_instance)
 
     call process%final ()
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_4"
 
   end subroutine processes_4
 
 @ %def processes_4
 @
 \subsubsection{Structure function configuration}
 Configure structure functions (multi-channel) in a process object.
 <<Processes: execute tests>>=
   call test (processes_7, "processes_7", &
        "process configuration with structure functions", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_7
 <<Processes: tests>>=
   subroutine processes_7 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable, target :: process
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     real(default) :: sqrts
     type(pdg_array_t) :: pdg_in
     class(sf_data_t), allocatable, target :: data
     type(sf_config_t), dimension(:), allocatable :: sf_config
     type(sf_channel_t), dimension(2) :: sf_channel
 
     write (u, "(A)")  "* Test output: processes_7"
     write (u, "(A)")  "*   Purpose: initialize a process with &
          &structure functions"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and initialize a process object"
     write (u, "(A)")
 
     libname = "processes7"
     procname = libname
     run_id = "run7"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib)
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
 
     call process%setup_test_cores ()
     allocate (phs_test_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     write (u, "(A)")  "* Set beam, structure functions, and mappings"
     write (u, "(A)")
 
     sqrts = 1000
     call process%setup_beams_sqrts (sqrts, i_core = 1)
     call process%configure_phs ()
 
     pdg_in = 25
     allocate (sf_test_data_t :: data)
     select type (data)
     type is (sf_test_data_t)
        model => process%get_model_ptr ()
        call data%init (model, pdg_in)
     end select
 
     allocate (sf_config (2))
     call sf_config(1)%init ([1], data)
     call sf_config(2)%init ([2], data)
     call process%init_sf_chain (sf_config)
     deallocate (sf_config)
 
     call process%test_allocate_sf_channels (3)
 
     call sf_channel(1)%init (2)
     call sf_channel(1)%activate_mapping ([1,2])
     call process%set_sf_channel (2, sf_channel(1))
 
     call sf_channel(2)%init (2)
     call sf_channel(2)%set_s_mapping ([1,2])
     call process%set_sf_channel (3, sf_channel(2))
 
     call process%setup_mci ()
 
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call process%final ()
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_7"
 
   end subroutine processes_7
 
 @ %def processes_7
 @
 \subsubsection{Evaluating a process with structure function}
 Configure structure functions (single-channel) in a process object,
 create an instance, compute kinematics and evaluate.
 
 Note the order of operations when setting up structure functions and
 phase space.  The beams are first, they determine the [[sqrts]] value.
 We can also set up the chain of structure functions.  We then
 configure the phase space.  From this, we can obtain information about
 special configurations (resonances, etc.), which we need for
 allocating the possible structure-function channels (parameterizations
 and mappings).  Finally, we match phase-space channels onto
 structure-function channels.
 
 In the current example, this matching is trivial; we only have one
 structure-function channel.
 <<Processes: execute tests>>=
   call test (processes_8, "processes_8", &
        "process evaluation with structure functions", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_8
 <<Processes: tests>>=
   subroutine processes_8 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable, target :: process
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     real(default) :: sqrts
     type(process_instance_t), allocatable, target :: process_instance
     type(pdg_array_t) :: pdg_in
     class(sf_data_t), allocatable, target :: data
     type(sf_config_t), dimension(:), allocatable :: sf_config
     type(sf_channel_t) :: sf_channel
     type(particle_set_t) :: pset
 
     write (u, "(A)")  "* Test output: processes_8"
     write (u, "(A)")  "*   Purpose: evaluate a process with &
          &structure functions"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and initialize a process object"
     write (u, "(A)")
 
     libname = "processes8"
     procname = libname
     run_id = "run8"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib)
 
     call reset_interaction_counter ()
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
 
     call process%setup_test_cores ()
     allocate (phs_test_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     write (u, "(A)")  "* Set beam, structure functions, and mappings"
     write (u, "(A)")
 
     sqrts = 1000
     call process%setup_beams_sqrts (sqrts, i_core = 1)
 
     pdg_in = 25
     allocate (sf_test_data_t :: data)
     select type (data)
     type is (sf_test_data_t)
        model => process%get_model_ptr ()
        call data%init (model, pdg_in)
     end select
 
     allocate (sf_config (2))
     call sf_config(1)%init ([1], data)
     call sf_config(2)%init ([2], data)
     call process%init_sf_chain (sf_config)
     deallocate (sf_config)
 
     call process%configure_phs ()
 
     call process%test_allocate_sf_channels (1)
 
     call sf_channel%init (2)
     call sf_channel%activate_mapping ([1,2])
     call process%set_sf_channel (1, sf_channel)
 
     write (u, "(A)")  "* Complete process initialization"
     write (u, "(A)")
 
     call process%setup_mci ()
     call process%setup_terms ()
 
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Create a process instance"
     write (u, "(A)")
 
     allocate (process_instance)
     call process_instance%init (process)
 
     write (u, "(A)")  "* Set up kinematics and evaluate"
     write (u, "(A)")
 
     call process_instance%choose_mci (1)
     call process_instance%evaluate_sqme (1, &
          [0.8_default, 0.8_default, 0.1_default, 0.2_default])
     call process_instance%write (u)
 
     call process_instance%get_trace (pset, 1)
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Particle content:"
     write (u, "(A)")
 
     call write_separator (u)
     call pset%write (u)
     call write_separator (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Recover process instance"
     write (u, "(A)")
 
     call reset_interaction_counter (2)
 
     allocate (process_instance)
     call process_instance%init (process)
 
     call process_instance%choose_mci (1)
     call process_instance%set_trace (pset, 1, check_match = .false.)
     call process_instance%recover &
          (channel = 1, i_term = 1, update_sqme = .true., recover_phs = .true.)
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call pset%final ()
 
     call process_instance%final ()
     deallocate (process_instance)
 
     call process%final ()
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_8"
 
   end subroutine processes_8
 
 @ %def processes_8
 @
 \subsubsection{Multi-channel phase space and structure function}
 This is an extension of the previous example.  This time, we have two
 distinct structure-function channels which are matched to the two
 distinct phase-space channels.
 <<Processes: execute tests>>=
   call test (processes_9, "processes_9", &
        "multichannel kinematics and structure functions", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_9
 <<Processes: tests>>=
   subroutine processes_9 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable, target :: process
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     real(default) :: sqrts
     type(process_instance_t), allocatable, target :: process_instance
     type(pdg_array_t) :: pdg_in
     class(sf_data_t), allocatable, target :: data
     type(sf_config_t), dimension(:), allocatable :: sf_config
     type(sf_channel_t) :: sf_channel
     real(default), dimension(4) :: x_saved
     type(particle_set_t) :: pset
 
     write (u, "(A)")  "* Test output: processes_9"
     write (u, "(A)")  "*   Purpose: evaluate a process with &
          &structure functions"
     write (u, "(A)")  "*            in a multi-channel configuration"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and initialize a process object"
     write (u, "(A)")
 
     libname = "processes9"
     procname = libname
     run_id = "run9"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib)
 
     call reset_interaction_counter ()
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
 
     call process%setup_test_cores ()
     allocate (phs_test_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     write (u, "(A)")  "* Set beam, structure functions, and mappings"
     write (u, "(A)")
 
     sqrts = 1000
     call process%setup_beams_sqrts (sqrts, i_core = 1)
 
     pdg_in = 25
     allocate (sf_test_data_t :: data)
     select type (data)
     type is (sf_test_data_t)
        model => process%get_model_ptr ()
        call data%init (model, pdg_in)
     end select
 
     allocate (sf_config (2))
     call sf_config(1)%init ([1], data)
     call sf_config(2)%init ([2], data)
     call process%init_sf_chain (sf_config)
     deallocate (sf_config)
 
     call process%configure_phs ()
 
     call process%test_allocate_sf_channels (2)
 
     call sf_channel%init (2)
     call process%set_sf_channel (1, sf_channel)
 
     call sf_channel%init (2)
     call sf_channel%activate_mapping ([1,2])
     call process%set_sf_channel (2, sf_channel)
 
     call process%test_set_component_sf_channel ([1, 2])
 
     write (u, "(A)")  "* Complete process initialization"
     write (u, "(A)")
 
     call process%setup_mci ()
     call process%setup_terms ()
 
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Create a process instance"
     write (u, "(A)")
 
     allocate (process_instance)
     call process_instance%init (process)
 
     write (u, "(A)")  "* Set up kinematics in channel 1 and evaluate"
     write (u, "(A)")
 
     call process_instance%choose_mci (1)
     call process_instance%evaluate_sqme (1, &
          [0.8_default, 0.8_default, 0.1_default, 0.2_default])
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Extract MC input parameters"
     write (u, "(A)")
 
     write (u, "(A)")  "Channel 1:"
     call process_instance%get_mcpar (1, x_saved)
     write (u, "(2x,9(1x,F7.5))")  x_saved
 
     write (u, "(A)")  "Channel 2:"
     call process_instance%get_mcpar (2, x_saved)
     write (u, "(2x,9(1x,F7.5))")  x_saved
 
     write (u, "(A)")
     write (u, "(A)")  "* Set up kinematics in channel 2 and evaluate"
     write (u, "(A)")
 
     call process_instance%evaluate_sqme (2, x_saved)
     call process_instance%write (u)
 
     call process_instance%get_trace (pset, 1)
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Recover process instance for channel 2"
     write (u, "(A)")
 
     call reset_interaction_counter (2)
 
     allocate (process_instance)
     call process_instance%init (process)
 
     call process_instance%choose_mci (1)
     call process_instance%set_trace (pset, 1, check_match = .false.)
     call process_instance%recover &
          (channel = 2, i_term = 1, update_sqme = .true., recover_phs = .true.)
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call pset%final ()
 
     call process_instance%final ()
     deallocate (process_instance)
 
     call process%final ()
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_9"
 
   end subroutine processes_9
 
 @ %def processes_9
 @
 \subsubsection{Event generation}
 Activate the MC integrator for the process object and use it to
 generate a single event.  Note that the test integrator does not
 require integration in preparation for generating events.
 <<Processes: execute tests>>=
   call test (processes_10, "processes_10", &
        "event generation", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_10
 <<Processes: tests>>=
   subroutine processes_10 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable, target :: process
     class(mci_t), allocatable :: mci_template
     class(mci_t), pointer :: mci
     class(phs_config_t), allocatable :: phs_config_template
     real(default) :: sqrts
     type(process_instance_t), allocatable, target :: process_instance
 
     write (u, "(A)")  "* Test output: processes_10"
     write (u, "(A)")  "*   Purpose: generate events for a process without &
          &structure functions"
     write (u, "(A)")  "*            in a multi-channel configuration"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and initialize a process object"
     write (u, "(A)")
 
     libname = "processes10"
     procname = libname
     run_id = "run10"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib)
 
     call reset_interaction_counter ()
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
 
     call process%setup_test_cores ()
     allocate (mci_test_t :: mci_template)
     select type (mci_template)
     type is (mci_test_t);  call mci_template%set_divisions (100)
     end select
     allocate (phs_test_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     write (u, "(A)")  "* Prepare a trivial beam setup"
     write (u, "(A)")
 
     sqrts = 1000
     call process%setup_beams_sqrts (sqrts, i_core = 1)
     call process%configure_phs ()
 
     call process%setup_mci ()
 
     write (u, "(A)")  "* Complete process initialization"
     write (u, "(A)")
 
     call process%setup_terms ()
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Create a process instance"
     write (u, "(A)")
 
     allocate (process_instance)
     call process_instance%init (process)
 
     write (u, "(A)")  "* Generate weighted event"
     write (u, "(A)")
 
     call process%test_get_mci_ptr (mci)
     select type (mci)
     type is (mci_test_t)
        ! This ensures that the next 'random' numbers are 0.3, 0.5, 0.7
        call mci%rng%init (3)
        ! Include the constant PHS factor in the stored maximum of the integrand
        call mci%set_max_factor (conv * twopi4 &
             / (2 * sqrt (lambda (sqrts **2, 125._default**2, 125._default**2))))
     end select
 
     call process_instance%generate_weighted_event (1)
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Generate unweighted event"
     write (u, "(A)")
 
     call process_instance%generate_unweighted_event (1)
     call process%test_get_mci_ptr (mci)
     select type (mci)
     type is (mci_test_t)
        write (u, "(A,I0)")  " Success in try ", mci%tries
        write (u, "(A)")
     end select
 
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call process_instance%final ()
     deallocate (process_instance)
 
     call process%final ()
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_10"
 
   end subroutine processes_10
 
 @ %def processes_10
 @
 \subsubsection{Integration}
 Activate the MC integrator for the process object and use it to
 integrate over phase space.
 <<Processes: execute tests>>=
   call test (processes_11, "processes_11", &
        "integration", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_11
 <<Processes: tests>>=
   subroutine processes_11 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable, target :: process
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     real(default) :: sqrts
     type(process_instance_t), allocatable, target :: process_instance
 
     write (u, "(A)")  "* Test output: processes_11"
     write (u, "(A)")  "*   Purpose: integrate a process without &
          &structure functions"
     write (u, "(A)")  "*            in a multi-channel configuration"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and initialize a process object"
     write (u, "(A)")
 
     libname = "processes11"
     procname = libname
     run_id = "run11"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib)
 
     call reset_interaction_counter ()
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
 
     call process%setup_test_cores ()
     allocate (mci_test_t :: mci_template)
     select type (mci_template)
     type is (mci_test_t)
        call mci_template%set_divisions (100)
     end select
     allocate (phs_test_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     write (u, "(A)")  "* Prepare a trivial beam setup"
     write (u, "(A)")
 
     sqrts = 1000
     call process%setup_beams_sqrts (sqrts, i_core = 1)
     call process%configure_phs ()
 
     call process%setup_mci ()
 
     write (u, "(A)")  "* Complete process initialization"
     write (u, "(A)")
 
     call process%setup_terms ()
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Create a process instance"
     write (u, "(A)")
 
     allocate (process_instance)
     call process_instance%init (process)
 
     write (u, "(A)")  "* Integrate with default test parameters"
     write (u, "(A)")
 
     call process_instance%integrate (1, n_it=1, n_calls=10000)
     call process%final_integration (1)
 
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A,ES13.7)")  " Integral divided by phs factor = ", &
          process%get_integral (1) &
          / process_instance%term(1)%k_term%phs_factor
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call process_instance%final ()
     deallocate (process_instance)
 
     call process%final ()
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_11"
 
   end subroutine processes_11
 
 @ %def processes_11
 @
 \subsubsection{Complete events}
 For the purpose of simplifying further tests, we implement a
 convenience routine that initializes a process and prepares a single
 event.  This is a wrapup of the test [[processes_10]].
 
 The procedure is re-exported by the [[processes_ut]] module.
 <<Processes: public test auxiliary>>=
   public :: prepare_test_process
 <<Processes: test auxiliary>>=
   subroutine prepare_test_process (process, process_instance, model)
     type(process_t), intent(out), target :: process
     type(process_instance_t), intent(out), target :: process_instance
     class(model_data_t), intent(in), target :: model
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     class(model_data_t), pointer :: process_model
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(mci_t), allocatable :: mci_template
     class(mci_t), pointer :: mci
     class(phs_config_t), allocatable :: phs_config_template
     real(default) :: sqrts
     libname = "processes_test"
     procname = libname
     run_id = "run_test"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib)
     call reset_interaction_counter ()
     allocate (process_model)
     call process_model%init (model%get_name (), &
          model%get_n_real (), &
          model%get_n_complex (), &
          model%get_n_field (), &
          model%get_n_vtx ())
     call process_model%copy_from (model)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, process_model)
     call process%setup_test_cores ()
     allocate (mci_test_t :: mci_template)
     select type (mci_template)
     type is (mci_test_t);  call mci_template%set_divisions (100)
     end select
     allocate (phs_test_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
     sqrts = 1000
     call process%setup_beams_sqrts (sqrts, i_core = 1)
     call process%configure_phs ()
     call process%setup_mci ()
     call process%setup_terms ()
     call process_instance%init (process)
     call process%test_get_mci_ptr (mci)
     select type (mci)
     type is (mci_test_t)
        ! This ensures that the next 'random' numbers are 0.3, 0.5, 0.7
        call mci%rng%init (3)
        ! Include the constant PHS factor in the stored maximum of the integrand
        call mci%set_max_factor (conv * twopi4 &
             / (2 * sqrt (lambda (sqrts **2, 125._default**2, 125._default**2))))
     end select
     call process%nullify_library_pointer ()  ! avoid dangling pointer
   end subroutine prepare_test_process
 
 @ %def prepare_test_process
 @ Here we do the cleanup of the process and process instance emitted
 by the previous routine.
 <<Processes: public test auxiliary>>=
   public :: cleanup_test_process
 <<Processes: test auxiliary>>=
   subroutine cleanup_test_process (process, process_instance)
     type(process_t), intent(inout) :: process
     type(process_instance_t), intent(inout) :: process_instance
     call process_instance%final ()
     call process%final ()
   end subroutine cleanup_test_process
 
 @ %def cleanup_test_process
 @
 This is the actual test.  Prepare the test process and event, fill
 all evaluators, and display the results.  Use a particle set as
 temporary storage, read kinematics and recalculate the event.
 <<Processes: execute tests>>=
   call test (processes_12, "processes_12", &
        "event post-processing", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_12
 <<Processes: tests>>=
   subroutine processes_12 (u)
     integer, intent(in) :: u
     type(process_t), allocatable, target :: process
     type(process_instance_t), allocatable, target :: process_instance
     type(particle_set_t) :: pset
     type(model_data_t), target :: model
 
     write (u, "(A)")  "* Test output: processes_12"
     write (u, "(A)")  "*   Purpose: generate a complete partonic event"
     write (u, "(A)")
 
     call model%init_test ()
 
     write (u, "(A)")  "* Build and initialize process and process instance &
          &and generate event"
     write (u, "(A)")
 
     allocate (process)
     allocate (process_instance)
     call prepare_test_process (process, process_instance, model)
     call process_instance%setup_event_data (i_core = 1)
 
     call process%prepare_simulation (1)
     call process_instance%init_simulation (1)
     call process_instance%generate_weighted_event (1)
     call process_instance%evaluate_event_data ()
 
     call process_instance%write (u)
 
     call process_instance%get_trace (pset, 1)
 
     call process_instance%final_simulation (1)
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Recover kinematics and recalculate"
     write (u, "(A)")
 
     call reset_interaction_counter (2)
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%setup_event_data ()
 
     call process_instance%choose_mci (1)
     call process_instance%set_trace (pset, 1, check_match = .false.)
     call process_instance%recover &
          (channel = 1, i_term = 1, update_sqme = .true., recover_phs = .true.)
 
     call process_instance%recover_event ()
     call process_instance%evaluate_event_data ()
 
     call process_instance%write (u)
 
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call cleanup_test_process (process, process_instance)
     deallocate (process_instance)
     deallocate (process)
 
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_12"
 
   end subroutine processes_12
 
 @ %def processes_12
 @
 \subsubsection{Colored interaction}
 This test specifically checks the transformation of process data
 (flavor, helicity, and color) into an interaction in a process term.
 
 We use the [[test_t]] process core (which has no nontrivial
 particles), but call only the [[is_allowed]] method, which always
 returns true.
 <<Processes: execute tests>>=
   call test (processes_13, "processes_13", &
        "colored interaction", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_13
 <<Processes: tests>>=
   subroutine processes_13 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(model_data_t), target :: model
     type(process_term_t) :: term
     class(prc_core_t), allocatable :: core
 
     write (u, "(A)")  "* Test output: processes_13"
     write (u, "(A)")  "*   Purpose: initialized a colored interaction"
     write (u, "(A)")
 
     write (u, "(A)")  "* Set up a process constants block"
     write (u, "(A)")
 
     call os_data_init (os_data)
     call model%init_sm_test ()
 !    call model_list%read_model (var_str ("QCD"), var_str ("QCD.mdl"), &
 !         os_data, model)
     allocate (test_t :: core)
 
     associate (data => term%data)
       data%n_in = 2
       data%n_out = 3
       data%n_flv = 2
       data%n_hel = 2
       data%n_col = 2
       data%n_cin = 2
 
       allocate (data%flv_state (5, 2))
       data%flv_state (:,1) = [ 1, 21, 1, 21, 21]
       data%flv_state (:,2) = [ 2, 21, 2, 21, 21]
 
       allocate (data%hel_state (5, 2))
       data%hel_state (:,1) = [1, 1, 1, 1, 0]
       data%hel_state (:,2) = [1,-1, 1,-1, 0]
 
       allocate (data%col_state (2, 5, 2))
       data%col_state (:,:,1) = &
            reshape ([[1, 0], [2,-1], [3, 0], [2,-3], [0,0]], [2,5])
       data%col_state (:,:,2) = &
            reshape ([[1, 0], [2,-3], [3, 0], [2,-1], [0,0]], [2,5])
 
       allocate (data%ghost_flag (5, 2))
       data%ghost_flag(1:4,:) = .false.
       data%ghost_flag(5,:) = .true.
 
     end associate
 
     write (u, "(A)")  "* Set up the interaction"
     write (u, "(A)")
 
     call reset_interaction_counter ()
     call term%setup_interaction (core, model)
     call term%int%basic_write (u)
 
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_13"
   end subroutine processes_13
 
 @ %def processes_13
 @
 \subsubsection{MD5 sums}
 Configure a process with structure functions (multi-channel) and
 compute MD5 sums
 <<Processes: execute tests>>=
   call test (processes_14, "processes_14", &
        "process configuration and MD5 sum", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_14
 <<Processes: tests>>=
   subroutine processes_14 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable, target :: process
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     real(default) :: sqrts
     type(pdg_array_t) :: pdg_in
     class(sf_data_t), allocatable, target :: data
     type(sf_config_t), dimension(:), allocatable :: sf_config
     type(sf_channel_t), dimension(3) :: sf_channel
 
     write (u, "(A)")  "* Test output: processes_14"
     write (u, "(A)")  "*   Purpose: initialize a process with &
          &structure functions"
     write (u, "(A)")  "*            and compute MD5 sum"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and initialize a process object"
     write (u, "(A)")
 
     libname = "processes7"
     procname = libname
     run_id = "run7"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib)
     call lib%compute_md5sum ()
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
 
     call process%setup_test_cores ()
     allocate (phs_test_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     write (u, "(A)")  "* Set beam, structure functions, and mappings"
     write (u, "(A)")
 
     sqrts = 1000
     call process%setup_beams_sqrts (sqrts, i_core = 1)
     call process%configure_phs ()
 
     pdg_in = 25
     allocate (sf_test_data_t :: data)
     select type (data)
     type is (sf_test_data_t)
        model => process%get_model_ptr ()
        call data%init (model, pdg_in)
     end select
 
     call process%test_allocate_sf_channels (3)
 
     allocate (sf_config (2))
     call sf_config(1)%init ([1], data)
     call sf_config(2)%init ([2], data)
     call process%init_sf_chain (sf_config)
     deallocate (sf_config)
 
     call sf_channel(1)%init (2)
     call process%set_sf_channel (1, sf_channel(1))
 
     call sf_channel(2)%init (2)
     call sf_channel(2)%activate_mapping ([1,2])
     call process%set_sf_channel (2, sf_channel(2))
 
     call sf_channel(3)%init (2)
     call sf_channel(3)%set_s_mapping ([1,2])
     call process%set_sf_channel (3, sf_channel(3))
 
     call process%setup_mci ()
 
     call process%compute_md5sum ()
 
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call process%final ()
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_14"
 
   end subroutine processes_14
 
 @ %def processes_14
 @
 \subsubsection{Decay Process Evaluation}
 Initialize an evaluate a decay process.
 <<Processes: execute tests>>=
   call test (processes_15, "processes_15", &
        "decay process", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_15
 <<Processes: tests>>=
   subroutine processes_15 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable, target :: process
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     type(process_instance_t), allocatable, target :: process_instance
     type(particle_set_t) :: pset
 
     write (u, "(A)")  "* Test output: processes_15"
     write (u, "(A)")  "*   Purpose: initialize a decay process object"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and load a test library with one process"
     write (u, "(A)")
 
     libname = "processes15"
     procname = libname
     run_id = "run15"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib, scattering = .false., &
          decay = .true.)
 
     allocate (model)
     call model%init_test ()
     call model%set_par (var_str ("ff"), 0.4_default)
     call model%set_par (var_str ("mf"), &
          model%get_real (var_str ("ff")) * model%get_real (var_str ("ms")))
 
     write (u, "(A)")  "* Initialize a process object"
     write (u, "(A)")
 
     allocate (process)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
 
     call process%setup_test_cores ()
     allocate (phs_single_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     write (u, "(A)")  "* Prepare a trivial beam setup"
     write (u, "(A)")
 
     call process%setup_beams_decay (i_core = 1)
     call process%configure_phs ()
     call process%setup_mci ()
 
     write (u, "(A)")  "* Complete process initialization"
     write (u, "(A)")
 
     call process%setup_terms ()
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Create a process instance"
     write (u, "(A)")
 
     call reset_interaction_counter (3)
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Inject a set of random numbers"
     write (u, "(A)")
 
     call process_instance%choose_mci (1)
     call process_instance%set_mcpar ([0._default, 0._default])
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Set up hard kinematics"
     write (u, "(A)")
 
     call process_instance%select_channel (1)
     call process_instance%compute_seed_kinematics ()
     call process_instance%compute_hard_kinematics ()
 
     write (u, "(A)")  "* Evaluate matrix element and square"
     write (u, "(A)")
 
     call process_instance%compute_eff_kinematics ()
     call process_instance%evaluate_expressions ()
     call process_instance%compute_other_channels ()
     call process_instance%evaluate_trace ()
     call process_instance%write (u)
 
     call process_instance%get_trace (pset, 1)
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Particle content:"
     write (u, "(A)")
 
     call write_separator (u)
     call pset%write (u)
     call write_separator (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Recover process instance"
     write (u, "(A)")
 
     call reset_interaction_counter (3)
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%choose_mci (1)
     call process_instance%set_trace (pset, 1, check_match = .false.)
     call process_instance%recover (1, 1, .true., .true.)
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call pset%final ()
     call process_instance%final ()
     deallocate (process_instance)
 
     call process%final ()
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_15"
 
   end subroutine processes_15
 
 @ %def processes_15
 @
 \subsubsection{Integration: decay}
 Activate the MC integrator for the decay object and use it to
 integrate over phase space.
 <<Processes: execute tests>>=
   call test (processes_16, "processes_16", &
        "decay integration", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_16
 <<Processes: tests>>=
   subroutine processes_16 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable, target :: process
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     type(process_instance_t), allocatable, target :: process_instance
 
     write (u, "(A)")  "* Test output: processes_16"
     write (u, "(A)")  "*   Purpose: integrate a process without &
          &structure functions"
     write (u, "(A)")  "*            in a multi-channel configuration"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and initialize a process object"
     write (u, "(A)")
 
     libname = "processes16"
     procname = libname
     run_id = "run16"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib, scattering = .false., &
          decay = .true.)
 
     call reset_interaction_counter ()
 
     allocate (model)
     call model%init_test ()
     call model%set_par (var_str ("ff"), 0.4_default)
     call model%set_par (var_str ("mf"), &
          model%get_real (var_str ("ff")) * model%get_real (var_str ("ms")))
 
     allocate (process)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
 
     call process%setup_test_cores ()
     allocate (mci_midpoint_t :: mci_template)
     allocate (phs_single_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     write (u, "(A)")  "* Prepare a trivial beam setup"
     write (u, "(A)")
 
     call process%setup_beams_decay (i_core = 1)
     call process%configure_phs ()
 
     call process%setup_mci ()
 
     write (u, "(A)")  "* Complete process initialization"
     write (u, "(A)")
 
     call process%setup_terms ()
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Create a process instance"
     write (u, "(A)")
 
     allocate (process_instance)
     call process_instance%init (process)
 
     write (u, "(A)")  "* Integrate with default test parameters"
     write (u, "(A)")
 
     call process_instance%integrate (1, n_it=1, n_calls=10000)
     call process%final_integration (1)
 
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A,ES13.7)")  " Integral divided by phs factor = ", &
          process%get_integral (1) &
          / process_instance%term(1)%k_term%phs_factor
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call process_instance%final ()
     deallocate (process_instance)
 
     call process%final ()
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_16"
 
   end subroutine processes_16
 
 @ %def processes_16
 @
 \subsubsection{Decay Process Evaluation}
 Initialize an evaluate a decay process for a moving particle.
 <<Processes: execute tests>>=
   call test (processes_17, "processes_17", &
        "decay of moving particle", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_17
 <<Processes: tests>>=
   subroutine processes_17 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable, target :: process
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     type(process_instance_t), allocatable, target :: process_instance
     type(particle_set_t) :: pset
     type(flavor_t) :: flv_beam
     real(default) :: m, p, E
 
     write (u, "(A)")  "* Test output: processes_17"
     write (u, "(A)")  "*   Purpose: initialize a decay process object"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and load a test library with one process"
     write (u, "(A)")
 
     libname = "processes17"
     procname = libname
     run_id = "run17"
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
 
     call prc_test_create_library (libname, lib, scattering = .false., &
          decay = .true.)
 
     write (u, "(A)")  "* Initialize a process object"
     write (u, "(A)")
 
     allocate (model)
     call model%init_test ()
     call model%set_par (var_str ("ff"), 0.4_default)
     call model%set_par (var_str ("mf"), &
          model%get_real (var_str ("ff")) * model%get_real (var_str ("ms")))
 
     allocate (process)
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
 
     call process%setup_test_cores ()
     allocate (phs_single_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     write (u, "(A)")  "* Prepare a trivial beam setup"
     write (u, "(A)")
 
     call process%setup_beams_decay (rest_frame = .false., i_core = 1)
     call process%configure_phs ()
     call process%setup_mci ()
 
     write (u, "(A)")  "* Complete process initialization"
     write (u, "(A)")
 
     call process%setup_terms ()
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Create a process instance"
     write (u, "(A)")
 
     call reset_interaction_counter (3)
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Set parent momentum and random numbers"
     write (u, "(A)")
 
     call process_instance%choose_mci (1)
     call process_instance%set_mcpar ([0._default, 0._default])
 
     model => process%get_model_ptr ()
     call flv_beam%init (25, model)
     m = flv_beam%get_mass ()
     p = 3 * m / 4
     E = sqrt (m**2 + p**2)
     call process_instance%set_beam_momenta ([vector4_moving (E, p, 3)])
 
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Set up hard kinematics"
     write (u, "(A)")
 
     call process_instance%select_channel (1)
     call process_instance%compute_seed_kinematics ()
     call process_instance%compute_hard_kinematics ()
 
     write (u, "(A)")  "* Evaluate matrix element and square"
     write (u, "(A)")
 
     call process_instance%compute_eff_kinematics ()
     call process_instance%evaluate_expressions ()
     call process_instance%compute_other_channels ()
     call process_instance%evaluate_trace ()
     call process_instance%write (u)
 
     call process_instance%get_trace (pset, 1)
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Particle content:"
     write (u, "(A)")
 
     call write_separator (u)
     call pset%write (u)
     call write_separator (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Recover process instance"
     write (u, "(A)")
 
     call reset_interaction_counter (3)
 
     allocate (process_instance)
     call process_instance%init (process)
 
     call process_instance%choose_mci (1)
     call process_instance%set_trace (pset, 1, check_match = .false.)
     call process_instance%recover (1, 1, .true., .true.)
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call pset%final ()
     call process_instance%final ()
     deallocate (process_instance)
 
     call process%final ()
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_17"
 
   end subroutine processes_17
 
 @ %def processes_17
 @
 \subsubsection{Resonances in Phase Space}
 This test demonstrates the extraction of the resonance-history set from the
 generated phase space.  We need a nontrivial process, but no matrix element.
 This is provided by the [[prc_template]] method, using the [[SM]] model.  We
 also need the [[phs_wood]] method, otherwise we would not have resonances in
 the phase space configuration.
 <<Processes: execute tests>>=
   call test (processes_18, "processes_18", &
        "extract resonance history set", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_18
 <<Processes: tests>>=
   subroutine processes_18 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: model_name
     type(os_data_t) :: os_data
     class(model_data_t), pointer :: model
     class(vars_t), pointer :: vars
     type(process_t), pointer :: process
     type(resonance_history_set_t) :: res_set
     integer :: i
 
     write (u, "(A)")  "* Test output: processes_18"
     write (u, "(A)")  "*   Purpose: extra resonance histories"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build and load a test library with one process"
     write (u, "(A)")
 
     libname = "processes_18_lib"
     procname = "processes_18_p"
 
     call os_data_init (os_data)
 
     call syntax_phs_forest_init ()
 
     model_name = "SM"
     call prepare_model (model, model_name, vars)
 
     write (u, "(A)")  "* Initialize a process library with one process"
     write (u, "(A)")
 
     call prepare_resonance_test_library (lib, libname, procname, model, os_data, u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Initialize a process object with phase space"
 
     allocate (process)
     call prepare_resonance_test_process (process, lib, procname, model, os_data)
 
     write (u, "(A)")
     write (u, "(A)")  "* Extract resonance history set"
     write (u, "(A)")
 
     call process%extract_resonance_history_set (res_set)
     call res_set%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call process%final ()
     deallocate (process)
 
     call syntax_phs_forest_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_18"
 
   end subroutine processes_18
 
 @ %def processes_18
 @ Auxiliary subroutine that constructs the process library for the above test.
 <<Processes: test auxiliary>>=
   subroutine prepare_resonance_test_library &
        (lib, libname, procname, model, os_data, u)
     type(process_library_t), target, intent(out) :: lib
     type(string_t), intent(in) :: libname
     type(string_t), intent(in) :: procname
     class(model_data_t), intent(in), pointer :: model
     type(os_data_t), intent(in) :: os_data
     integer, intent(in) :: u
     type(string_t), dimension(:), allocatable :: prt_in, prt_out
     class(prc_core_def_t), allocatable :: def
     type(process_def_entry_t), pointer :: entry
 
     call lib%init (libname)
 
     allocate (prt_in (2), prt_out (3))
     prt_in = [var_str ("e+"), var_str ("e-")]
     prt_out = [var_str ("d"), var_str ("ubar"), var_str ("W+")]
 
     allocate (template_me_def_t :: def)
     select type (def)
     type is (template_me_def_t)
        call def%init (model, prt_in, prt_out, unity = .false.)
     end select
     allocate (entry)
     call entry%init (procname, &
          model_name = model%get_name (), &
          n_in = 2, n_components = 1)
     call entry%import_component (1, n_out = size (prt_out), &
          prt_in  = new_prt_spec (prt_in), &
          prt_out = new_prt_spec (prt_out), &
          method  = var_str ("template"), &
          variant = def)
     call entry%write (u)
 
     call lib%append (entry)
 
     call lib%configure (os_data)
     call lib%write_makefile (os_data, force = .true., verbose = .false.)
     call lib%clean (os_data, distclean = .false.)
     call lib%write_driver (force = .true.)
     call lib%load (os_data)
 
   end subroutine prepare_resonance_test_library
 
 @ %def prepare_resonance_test_library
 @ We want a test process which has been initialized up to the point where we
 can evaluate the matrix element.  This is in fact rather complicated.  We copy
 the steps from [[integration_setup_process]] in the [[integrate]] module,
 which is not available at this point.
 <<Processes: test auxiliary>>=
   subroutine prepare_resonance_test_process &
        (process, lib, procname, model, os_data)
     class(process_t), intent(out), target :: process
     type(process_library_t), intent(in), target :: lib
     type(string_t), intent(in) :: procname
     class(model_data_t), intent(inout), pointer :: model
     type(os_data_t), intent(in) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     real(default) :: sqrts
 
     allocate (rng_test_factory_t :: rng_factory)
 
     call process%init (procname, var_str (""), &
          lib, os_data, qcd, rng_factory, model)
 
     allocate (phs_wood_config_t :: phs_config_template)
     allocate (mci_none_t :: mci_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     call process%setup_test_cores (type_string = var_str ("template"))
 
     sqrts = 1000
     call process%setup_beams_sqrts (sqrts, i_core = 1)
     call process%configure_phs ()
     call process%setup_mci ()
 
     call process%setup_terms ()
 
   end subroutine prepare_resonance_test_process
 
 @ %def prepare_resonance_test_process
 @
 \subsubsection{Add after evaluate hook(s)}
 Initialize a process and process instance, add a trivial process hook,
 choose a sampling point and fill the process instance.
 
 We use the same trivial process as for the previous test.  All
 momentum and state dependence is trivial, so we just test basic
 functionality.
 <<Processes: test types>>=
   type, extends(process_instance_hook_t) :: process_instance_hook_test_t
     integer :: unit
     character(len=15) :: name
   contains
     procedure :: init => process_instance_hook_test_init
     procedure :: final => process_instance_hook_test_final
     procedure :: evaluate => process_instance_hook_test_evaluate
   end type process_instance_hook_test_t
 
 @
 <<Processes: test auxiliary>>=
   subroutine process_instance_hook_test_init (hook, var_list, instance)
     class(process_instance_hook_test_t), intent(inout), target :: hook
     type(var_list_t), intent(in) :: var_list
     class(process_instance_t), intent(in), target :: instance
   end subroutine process_instance_hook_test_init
 
   subroutine process_instance_hook_test_final (hook)
     class(process_instance_hook_test_t), intent(inout) :: hook
   end subroutine process_instance_hook_test_final
 
   subroutine process_instance_hook_test_evaluate (hook, instance)
     class(process_instance_hook_test_t), intent(inout) :: hook
     class(process_instance_t), intent(in), target :: instance
     write (hook%unit, "(A)") "Execute hook:"
     write (hook%unit, "(2X,A,1X,A,I0,A)") hook%name, "(", len (trim (hook%name)), ")"
   end subroutine process_instance_hook_test_evaluate
 
 @
 <<Processes: execute tests>>=
   call test (processes_19, "processes_19", &
        "add trivial hooks to a process instance ", &
        u, results)
 <<Processes: test declarations>>=
   public :: processes_19
 <<Processes: tests>>=
   subroutine processes_19 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_t), allocatable, target :: process
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     real(default) :: sqrts
     type(process_instance_t) :: process_instance
     class(process_instance_hook_t), allocatable, target :: process_instance_hook, process_instance_hook2
     type(particle_set_t) :: pset
 
     write (u, "(A)")  "* Test output: processes_19"
     write (u, "(A)")  "*   Purpose: allocate process instance &
          &and add an after evaluate hook"
     write (u, "(A)")
 
     write (u, "(A)")
     write (u, "(A)")  "* Allocate a process instance"
     write (u, "(A)")
 
     call process_instance%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Allocate hook and add to process instance"
     write (u, "(A)")
 
     allocate (process_instance_hook_test_t :: process_instance_hook)
     call process_instance%append_after_hook (process_instance_hook)
 
     allocate (process_instance_hook_test_t :: process_instance_hook2)
     call process_instance%append_after_hook (process_instance_hook2)
 
     select type (process_instance_hook)
     type is (process_instance_hook_test_t)
        process_instance_hook%unit = u
        process_instance_hook%name = "Hook 1"
     end select
     select type (process_instance_hook2)
     type is (process_instance_hook_test_t)
        process_instance_hook2%unit = u
        process_instance_hook2%name = "Hook 2"
     end select
 
     write (u, "(A)")  "* Evaluate matrix element and square"
     write (u, "(A)")
 
     call process_instance%evaluate_after_hook ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call process_instance_hook%final ()
     deallocate (process_instance_hook)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: processes_19"
 
   end subroutine processes_19
 
 @ %def processes_19
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Process Stacks}
 
 For storing and handling multiple processes, we define process stacks.
 These are ordinary stacks where new process entries are pushed onto
 the top.  We allow for multiple entries with identical process ID, but
 distinct run ID.
 
 The implementation is essentially identical to the [[prclib_stacks]] module
 above.  Unfortunately, Fortran supports no generic programming, so we do not
 make use of this fact.
 
 When searching for a specific process ID, we will get (a pointer to)
 the topmost process entry with that ID on the stack, which was entered
 last.  Usually, this is the best version of the process (in terms of
 integral, etc.)  Thus the stack terminology makes sense.
 <<[[process_stacks.f90]]>>=
 <<File header>>
 
 module process_stacks
 
 <<Use kinds>>
 <<Use strings>>
   use io_units
   use format_utils, only: write_separator
   use diagnostics
   use os_interface
   use sm_qcd
   use model_data
   use rng_base
   use variables
   use observables
   use process_libraries
   use process
 
 <<Standard module head>>
 
 <<Process stacks: public>>
 
 <<Process stacks: types>>
 
 contains
 
 <<Process stacks: procedures>>
 
 end module process_stacks
 @ %def process_stacks
 @
 \subsection{The process entry type}
 A process entry is a process object, augmented by a pointer to the
 next entry.  We do not need specific methods, all relevant methods are
 inherited.
 
 On higher level, processes should be prepared as process entry objects.
 <<Process stacks: public>>=
   public :: process_entry_t
 <<Process stacks: types>>=
   type, extends (process_t) :: process_entry_t
      type(process_entry_t), pointer :: next => null ()
   end type process_entry_t
 
 @ %def process_entry_t
 @
 \subsection{The process stack type}
 For easy conversion and lookup it is useful to store the filling
 number in the object.  The content is stored as a linked list.
 
 The [[var_list]] component stores process-specific results, so they
 can be retrieved as (pseudo) variables.
 
 The process stack can be linked to another one.  This allows us to
 work with stacks of local scope.
 <<Process stacks: public>>=
   public :: process_stack_t
 <<Process stacks: types>>=
   type :: process_stack_t
      integer :: n = 0
      type(process_entry_t), pointer :: first => null ()
      type(var_list_t), pointer :: var_list => null ()
      type(process_stack_t), pointer :: next => null ()
    contains
    <<Process stacks: process stack: TBP>>
   end type process_stack_t
 
 @ %def process_stack_t
 @ Finalize partly: deallocate the process stack and variable list
 entries, but keep the variable list as an empty object.  This way, the
 variable list links are kept.
 <<Process stacks: process stack: TBP>>=
   procedure :: clear => process_stack_clear
 <<Process stacks: procedures>>=
   subroutine process_stack_clear (stack)
     class(process_stack_t), intent(inout) :: stack
     type(process_entry_t), pointer :: process
     if (associated (stack%var_list)) then
        call stack%var_list%final ()
     end if
     do while (associated (stack%first))
        process => stack%first
        stack%first => process%next
        call process%final ()
        deallocate (process)
     end do
     stack%n = 0
   end subroutine process_stack_clear
 
 @ %def process_stack_clear
 @ Finalizer.  Clear and deallocate the variable list.
 <<Process stacks: process stack: TBP>>=
   procedure :: final => process_stack_final
 <<Process stacks: procedures>>=
   subroutine process_stack_final (object)
     class(process_stack_t), intent(inout) :: object
     call object%clear ()
     if (associated (object%var_list)) then
        deallocate (object%var_list)
     end if
   end subroutine process_stack_final
 
 @ %def process_stack_final
 @ Output.  The processes on the stack will be ordered LIFO, i.e.,
 backwards.
 <<Process stacks: process stack: TBP>>=
   procedure :: write => process_stack_write
 <<Process stacks: procedures>>=
   recursive subroutine process_stack_write (object, unit, pacify)
     class(process_stack_t), intent(in) :: object
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: pacify
     type(process_entry_t), pointer :: process
     integer :: u
     u = given_output_unit (unit)
     call write_separator (u, 2)
     select case (object%n)
     case (0)
        write (u, "(1x,A)")  "Process stack: [empty]"
        call write_separator (u, 2)
     case default
        write (u, "(1x,A)")  "Process stack:"
        process => object%first
        do while (associated (process))
           call process%write (.false., u, pacify = pacify)
           process => process%next
        end do
     end select
     if (associated (object%next)) then
        write (u, "(1x,A)")  "[Processes from context environment:]"
        call object%next%write (u, pacify)
     end if
   end subroutine process_stack_write
 
 @ %def process_stack_write
 @ The variable list is printed by a separate routine, since
 it should be linked to the global variable list, anyway.
 <<Process stacks: process stack: TBP>>=
   procedure :: write_var_list => process_stack_write_var_list
 <<Process stacks: procedures>>=
   subroutine process_stack_write_var_list (object, unit)
     class(process_stack_t), intent(in) :: object
     integer, intent(in), optional :: unit
     if (associated (object%var_list)) then
        call var_list_write (object%var_list, unit)
     end if
   end subroutine process_stack_write_var_list
 
 @ %def process_stack_write_var_list
 @ Short output.
 
 Since this is a stack, the default output ordering for each stack will be
 last-in, first-out.  To enable first-in, first-out, which is more likely to be
 requested, there is an optional [[fifo]] argument.
 <<Process stacks: process stack: TBP>>=
   procedure :: show => process_stack_show
 <<Process stacks: procedures>>=
   recursive subroutine process_stack_show (object, unit, fifo)
     class(process_stack_t), intent(in) :: object
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: fifo
     type(process_entry_t), pointer :: process
     logical :: reverse
     integer :: u, i, j
     u = given_output_unit (unit)
     reverse = .false.;  if (present (fifo))  reverse = fifo
     select case (object%n)
     case (0)
     case default
        if (.not. reverse) then
           process => object%first
           do while (associated (process))
              call process%show (u, verbose=.false.)
              process => process%next
           end do 
        else
           do i = 1, object%n
              process => object%first
              do j = 1, object%n - i
                 process => process%next
              end do
              call process%show (u, verbose=.false.)
           end do
        end if
     end select
     if (associated (object%next))  call object%next%show ()
   end subroutine process_stack_show
 
 @ %def process_stack_show
 @
 \subsection{Link}
 Link the current process stack to a global one.
 <<Process stacks: process stack: TBP>>=
   procedure :: link => process_stack_link
 <<Process stacks: procedures>>=
   subroutine process_stack_link (local_stack, global_stack)
     class(process_stack_t), intent(inout) :: local_stack
     type(process_stack_t), intent(in), target :: global_stack
     local_stack%next => global_stack
   end subroutine process_stack_link
 
 @ %def process_stack_link
 @ Initialize the process variable list and link the main variable list
 to it.
 <<Process stacks: process stack: TBP>>=
   procedure :: init_var_list => process_stack_init_var_list
 <<Process stacks: procedures>>=
   subroutine process_stack_init_var_list (stack, var_list)
     class(process_stack_t), intent(inout) :: stack
     type(var_list_t), intent(inout), optional :: var_list
     allocate (stack%var_list)
     if (present (var_list))  call var_list%link (stack%var_list)
   end subroutine process_stack_init_var_list
 
 @ %def process_stack_init_var_list
 @ Link the process variable list to a global
 variable list.
 <<Process stacks: process stack: TBP>>=
   procedure :: link_var_list => process_stack_link_var_list
 <<Process stacks: procedures>>=
   subroutine process_stack_link_var_list (stack, var_list)
     class(process_stack_t), intent(inout) :: stack
     type(var_list_t), intent(in), target :: var_list
     call stack%var_list%link (var_list)
   end subroutine process_stack_link_var_list
 
 @ %def process_stack_link_var_list
 @
 \subsection{Push}
 We take a process pointer and push it onto the stack.  The previous
 pointer is nullified.  Subsequently, the process is `owned' by the
 stack and will be finalized when the stack is deleted.
 <<Process stacks: process stack: TBP>>=
   procedure :: push => process_stack_push
 <<Process stacks: procedures>>=
   subroutine process_stack_push (stack, process)
     class(process_stack_t), intent(inout) :: stack
     type(process_entry_t), intent(inout), pointer :: process
     process%next => stack%first
     stack%first => process
     process => null ()
     stack%n = stack%n + 1
   end subroutine process_stack_push
 
 @ %def process_stack_push
 @ Inverse: Remove the last process pointer in the list and return it.
 <<Process stacks: process stack: TBP>>=
   procedure :: pop_last => process_stack_pop_last
 <<Process stacks: procedures>>=
   subroutine process_stack_pop_last (stack, process)
     class(process_stack_t), intent(inout) :: stack
     type(process_entry_t), intent(inout), pointer :: process
     type(process_entry_t), pointer :: previous
     integer :: i
     select case (stack%n)
     case (:0)
        process => null ()
     case (1)
        process => stack%first
        stack%first => null ()
        stack%n = 0
     case (2:)
        process => stack%first
        do i = 2, stack%n
           previous => process
           process => process%next
        end do
        previous%next => null ()
        stack%n = stack%n - 1
     end select
   end subroutine process_stack_pop_last
     
 @ %def process_stack_pop_last
 @ Initialize process variables for a given process ID, without setting
 values.
 <<Process stacks: process stack: TBP>>=
   procedure :: init_result_vars => process_stack_init_result_vars
 <<Process stacks: procedures>>=
   subroutine process_stack_init_result_vars (stack, id)
     class(process_stack_t), intent(inout) :: stack
     type(string_t), intent(in) :: id
     call var_list_init_num_id (stack%var_list, id)
     call var_list_init_process_results (stack%var_list, id)
   end subroutine process_stack_init_result_vars
 
 @ %def process_stack_init_result_vars
 @ Fill process variables with values.  This is executed after the
 integration pass.
 
 Note: We set only integral and error.  With multiple MCI records
 possible, the results for [[n_calls]], [[chi2]] etc. are not
 necessarily unique.  (We might set the efficiency, though.)
 <<Process stacks: process stack: TBP>>=
   procedure :: fill_result_vars => process_stack_fill_result_vars
 <<Process stacks: procedures>>=
   subroutine process_stack_fill_result_vars (stack, id)
     class(process_stack_t), intent(inout) :: stack
     type(string_t), intent(in) :: id
     type(process_t), pointer :: process
     process => stack%get_process_ptr (id)
     if (associated (process)) then
        call var_list_init_num_id (stack%var_list, id, process%get_num_id ())
        if (process%has_integral ()) then
           call var_list_init_process_results (stack%var_list, id, &
                integral = process%get_integral (), &
                error = process%get_error ())
        end if
     else
        call msg_bug ("process_stack_fill_result_vars: unknown process ID")
     end if
   end subroutine process_stack_fill_result_vars
 
 @ %def process_stack_fill_result_vars
 @ If one of the result variables has a local image in [[var_list_local]],
 update the value there as well.
 <<Process stacks: process stack: TBP>>=
   procedure :: update_result_vars => process_stack_update_result_vars
 <<Process stacks: procedures>>=
   subroutine process_stack_update_result_vars (stack, id, var_list_local)
     class(process_stack_t), intent(inout) :: stack
     type(string_t), intent(in) :: id
     type(var_list_t), intent(inout) :: var_list_local
     call update ("integral(" // id // ")")
     call update ("error(" // id // ")")
   contains
     subroutine update (var_name)
       type(string_t), intent(in) :: var_name
       real(default) :: value
       if (var_list_local%contains (var_name, follow_link = .false.)) then
          value = stack%var_list%get_rval (var_name)
          call var_list_local%set_real (var_name, value, is_known = .true.)
       end if
     end subroutine update
   end subroutine process_stack_update_result_vars
 
 @ %def process_stack_update_result_vars
 @
 \subsection{Data Access}
 Tell if a process exists.
 <<Process stacks: process stack: TBP>>=
   procedure :: exists => process_stack_exists
 <<Process stacks: procedures>>=
   function process_stack_exists (stack, id) result (flag)
     class(process_stack_t), intent(in) :: stack
     type(string_t), intent(in) :: id
     logical :: flag
     type(process_t), pointer :: process
     process => stack%get_process_ptr (id)
     flag = associated (process)
   end function process_stack_exists
 
 @ %def process_stack_exists
 @ Return a pointer to a process with specific ID.  Look also at a
 linked stack, if necessary.
 <<Process stacks: process stack: TBP>>=
   procedure :: get_process_ptr => process_stack_get_process_ptr
 <<Process stacks: procedures>>=
   recursive function process_stack_get_process_ptr (stack, id) result (ptr)
     class(process_stack_t), intent(in) :: stack
     type(string_t), intent(in) :: id
     type(process_t), pointer :: ptr
     type(process_entry_t), pointer :: entry
     ptr => null ()
     entry => stack%first
     do while (associated (entry))
        if (entry%get_id () == id) then
           ptr => entry%process_t
           return
        end if
        entry => entry%next
     end do
     if (associated (stack%next))  ptr => stack%next%get_process_ptr (id)
   end function process_stack_get_process_ptr
 
 @ %def process_stack_get_process_ptr
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[process_stacks_ut.f90]]>>=
 <<File header>>
 
 module process_stacks_ut
   use unit_tests
   use process_stacks_uti
 
 <<Standard module head>>
 
 <<Process stacks: public test>>
 
 contains
 
 <<Process stacks: test driver>>
 
 end module process_stacks_ut
 @ %def process_stacks_ut
 @
 <<[[process_stacks_uti.f90]]>>=
 <<File header>>
 
 module process_stacks_uti
 
 <<Use strings>>
   use os_interface
   use sm_qcd
   use model_data
   use process_libraries
   use rng_base
   use prc_test, only: prc_test_create_library
   use process, only: process_t
   use instances, only: process_instance_t
   use processes_ut, only: prepare_test_process
 
   use process_stacks
 
   use rng_base_ut, only: rng_test_factory_t
 
 <<Standard module head>>
 
 <<Process stacks: test declarations>>
 
 contains
 
 <<Process stacks: tests>>
 
 end module process_stacks_uti
 
 @ %def process_stacks_uti
 @ API: driver for the unit tests below.
 <<Process stacks: public test>>=
   public :: process_stacks_test
 <<Process stacks: test driver>>=
   subroutine process_stacks_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Process stacks: execute tests>>
   end subroutine process_stacks_test
 
 @ %def process_stacks_test
 @
 \subsubsection{Write an empty process stack}
 The most trivial test is to write an uninitialized process stack.
 <<Process stacks: execute tests>>=
   call test (process_stacks_1, "process_stacks_1", &
        "write an empty process stack", &
        u, results)
 <<Process stacks: test declarations>>=
   public :: process_stacks_1
 <<Process stacks: tests>>=
   subroutine process_stacks_1 (u)
     integer, intent(in) :: u
     type(process_stack_t) :: stack
 
     write (u, "(A)")  "* Test output: process_stacks_1"
     write (u, "(A)")  "*   Purpose: display an empty process stack"
     write (u, "(A)")
 
     call stack%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: process_stacks_1"
 
   end subroutine process_stacks_1
 
 @ %def process_stacks_1
 @
 \subsubsection{Fill a process stack}
 Fill a process stack with two (identical) processes.
 <<Process stacks: execute tests>>=
   call test (process_stacks_2, "process_stacks_2", &
        "fill a process stack", &
        u, results)
 <<Process stacks: test declarations>>=
   public :: process_stacks_2
 <<Process stacks: tests>>=
   subroutine process_stacks_2 (u)
     integer, intent(in) :: u
     type(process_stack_t) :: stack
     type(process_library_t), target :: lib
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_entry_t), pointer :: process => null ()
 
     write (u, "(A)")  "* Test output: process_stacks_2"
     write (u, "(A)")  "*   Purpose: fill a process stack"
     write (u, "(A)")
 
     write (u, "(A)")  "* Build, initialize and store two test processes"
     write (u, "(A)")
 
     libname = "process_stacks2"
     procname = libname
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
     call prc_test_create_library (libname, lib)
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     run_id = "run1"
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
     call stack%push (process)
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     run_id = "run2"
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
     call stack%push (process)
 
     call stack%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call stack%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: process_stacks_2"
 
   end subroutine process_stacks_2
 
 @ %def process_stacks_2
 @
 \subsubsection{Fill a process stack}
 Fill a process stack with two (identical) processes.
 <<Process stacks: execute tests>>=
   call test (process_stacks_3, "process_stacks_3", &
        "process variables", &
        u, results)
 <<Process stacks: test declarations>>=
   public :: process_stacks_3
 <<Process stacks: tests>>=
   subroutine process_stacks_3 (u)
     integer, intent(in) :: u
     type(process_stack_t) :: stack
     type(model_data_t), target :: model
     type(string_t) :: procname
     type(process_entry_t), pointer :: process => null ()
     type(process_instance_t), target :: process_instance
 
     write (u, "(A)")  "* Test output: process_stacks_3"
     write (u, "(A)")  "*   Purpose: setup process variables"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize process variables"
     write (u, "(A)")
 
     procname = "processes_test"
     call model%init_test ()
 
     write (u, "(A)")  "* Initialize process variables"
     write (u, "(A)")
 
     call stack%init_var_list ()
     call stack%init_result_vars (procname)
     call stack%write_var_list (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Build and integrate a test process"
     write (u, "(A)")
 
     allocate (process)
     call prepare_test_process (process%process_t, process_instance, model)
     call process_instance%integrate (1, 1, 1000)
     call process_instance%final ()
     call process%final_integration (1)
     call stack%push (process)
 
     write (u, "(A)")  "* Fill process variables"
     write (u, "(A)")
 
     call stack%fill_result_vars (procname)
     call stack%write_var_list (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call stack%final ()
 
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: process_stacks_3"
 
   end subroutine process_stacks_3
 
 @ %def process_stacks_3
 @
 \subsubsection{Linked a process stack}
 Fill two process stack, linked to each other.
 <<Process stacks: execute tests>>=
   call test (process_stacks_4, "process_stacks_4", &
        "linked stacks", &
        u, results)
 <<Process stacks: test declarations>>=
   public :: process_stacks_4
 <<Process stacks: tests>>=
   subroutine process_stacks_4 (u)
     integer, intent(in) :: u
     type(process_library_t), target :: lib
     type(process_stack_t), target :: stack1, stack2
     class(model_data_t), pointer :: model
     type(string_t) :: libname
     type(string_t) :: procname
     type(string_t) :: run_id
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     type(process_entry_t), pointer :: process => null ()
 
     write (u, "(A)")  "* Test output: process_stacks_4"
     write (u, "(A)")  "*   Purpose: link process stacks"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize process variables"
     write (u, "(A)")
 
     libname = "process_stacks_4_lib"
     procname = "process_stacks_4a"
 
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
 
     write (u, "(A)")  "* Initialize first process"
     write (u, "(A)")
 
     call prc_test_create_library (procname, lib)
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     run_id = "run1"
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
     call stack1%push (process)
 
     write (u, "(A)")  "* Initialize second process"
     write (u, "(A)")
 
     call stack2%link (stack1)
 
     procname = "process_stacks_4b"
     call prc_test_create_library (procname, lib)
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     run_id = "run2"
     call process%init (procname, run_id, &
          lib, os_data, qcd, rng_factory, model)
     call stack2%push (process)
 
     write (u, "(A)")  "* Show linked stacks"
     write (u, "(A)")
 
     call stack2%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call stack2%final ()
     call stack1%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: process_stacks_4"
 
   end subroutine process_stacks_4
 
 @ %def process_stacks_4
 @
Index: trunk/src/particles/particles.nw
===================================================================
--- trunk/src/particles/particles.nw	(revision 8163)
+++ trunk/src/particles/particles.nw	(revision 8164)
@@ -1,8373 +1,8385 @@
 %% -*- ess-noweb-default-code-mode: f90-mode; noweb-default-code-mode: f90-mode; -*-
 % WHIZARD code as NOWEB source: particle objects
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Particles}
 \includemodulegraph{particles}
 
 This chapter collects modules that implement particle objects, for use in
 event records.
 
 While within interactions, all correlations are
 manifest, a particle array is derived by selecting a particular
 quantum number set.  This involves tracing over all other particles,
 as far as polarization is concerned.  Thus, a particle has definite
 flavor, color, and a single-particle density matrix for polarization.
 \begin{description}
 \item[su\_algebra]
   We make use of $su(N)$ generators as the basis for representing
   polarization matrices.  This module defines the basis and provides
   the necessary transformation routines.
 \item[bloch\_vectors]
   This defines polarization objects in Bloch representation.  The
   object describes the spin density matrix of a particle,
   currently restricted to spin $0\ldots 2$.
 \item[polarizations]
   This extends the basic polarization object such that it supports
   properties of physical particles and appropriate constructors.
 \item[particles]
   Particle objects and particle lists, as the base of event records.
 \end{description}
 
 \clearpage
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{$su(N)$ Algebra}
 We need a specific choice of basis for a well-defined component
 representation.  The matrix elements of $T^a$ are
 ordered as $m=\ell,\ell-1,\ldots -\ell$, i.e., from highest down to
 lowest weight, for both row and column.
 
 We list first the generators of the $su(2)$ subalgebras which leave
 $|m|$ invariant ($|m|\neq 0$):
 \begin{equation}
   T^{b+1,b+2,b+3} \equiv \sigma^{1,2,3}
 \end{equation}
 acting on the respective subspace $|m|=\ell,\ell-1,\ldots$ for
 $b=0,1,\ldots$.  This defines generators $T^a$ for $a=1,\ldots 3N/2$
 ($\ldots 3(N-1)/2$) for $N$ even (odd), respectively.
 
 The following generators successively extend this to $su(4)$, $su(6)$,
 \ldots until $su(N)$ by adding first the missing off-diagonal and then
 diagonal generators.  The phase conventions are analogous.
 
 (It should be possible to code these conventions for generic spin, but
 in the current implementation we restrict ourselves to $s\leq 2$, i.e.,
 $N\leq 5$.)
 <<[[su_algebra.f90]]>>=
 <<File header>>
 
 module su_algebra
 
 <<Use kinds>>
   use physics_defs, only: SCALAR, SPINOR, VECTOR, VECTORSPINOR, TENSOR
 
 <<Standard module head>>
 
 <<su algebra: public>>
 
 contains
 
 <<su algebra: procedures>>
 
 end module su_algebra
 @ %def su_algebra
 @
 \subsection{$su(N)$ fundamental representation}
 The dimension of the basis for a given spin type.  consecutively, starting at
 [[SCALAR=1]].
 <<su algebra: public>>=
   public :: algebra_dimension
 <<su algebra: procedures>>=
   function algebra_dimension (s) result (n)
     integer :: n
     integer, intent(in) :: s
     n = fundamental_dimension (s) ** 2 - 1
   end function algebra_dimension
 
 @ %def algebra_dimension
 @ The dimension of the fundamental (defining) representation that we
 use.  This implementation assumes that the spin type is numerically
 equal to the fundamental dimension.
 <<su algebra: public>>=
   public :: fundamental_dimension
 <<su algebra: procedures>>=
   function fundamental_dimension (s) result (d)
     integer :: d
     integer, intent(in) :: s
     d = s
   end function fundamental_dimension
 
 @ %def fundamental_dimension
 @
 \subsection{Mapping between helicity and matrix index}
 Return the helicity that corresponds to a particular entry in the
 polarization matrix representation.  Helicities are counted downwards,
 in integers, and zero helicity is included (omitted) for odd (even)
 spin, respectively.
 <<su algebra: public>>=
   public :: helicity_value
 <<su algebra: procedures>>=
   function helicity_value (s, i) result (h)
     integer :: h
     integer, intent(in) :: s, i
     integer, dimension(1), parameter :: hh1 = [0]
     integer, dimension(2), parameter :: hh2 = [1, -1]
     integer, dimension(3), parameter :: hh3 = [1,  0, -1]
     integer, dimension(4), parameter :: hh4 = [2,  1, -1, -2]
     integer, dimension(5), parameter :: hh5 = [2,  1,  0, -1, -2]
     h = 0
     select case (s)
     case (SCALAR)
        select case (i)
        case (1:1);  h = hh1(i)
        end select
     case (SPINOR)
        select case (i)
        case (1:2);  h = hh2(i)
        end select
     case (VECTOR)
        select case (i)
        case (1:3);  h = hh3(i)
        end select
     case (VECTORSPINOR)
        select case (i)
        case (1:4);  h = hh4(i)
        end select
     case (TENSOR)
        select case (i)
        case (1:5);  h = hh5(i)
        end select
     end select
   end function helicity_value
 
 @ %def helicity_value
 @ Inverse: return the index that corresponds to a certain
 helicity value in the chosen representation.
 <<su algebra: public>>=
   public :: helicity_index
 <<su algebra: procedures>>=
   function helicity_index (s, h) result (i)
     integer, intent(in) :: s, h
     integer :: i
     integer, dimension(0:0), parameter :: hi1 = [1]
     integer, dimension(-1:1), parameter :: hi2 = [2, 0, 1]
     integer, dimension(-1:1), parameter :: hi3 = [3, 2, 1]
     integer, dimension(-2:2), parameter :: hi4 = [4, 3, 0, 2, 1]
     integer, dimension(-2:2), parameter :: hi5 = [5, 4, 3, 2, 1]
     select case (s)
     case (SCALAR)
        i = hi1(h)
     case (SPINOR)
        i = hi2(h)
     case (VECTOR)
        i = hi3(h)
     case (VECTORSPINOR)
        i = hi4(h)
     case (TENSOR)
        i = hi5(h)
     end select
   end function helicity_index
 
 @ %def helicity_index
 @
 \subsection{Generator Basis: Cartan Generators}
 For each supported spin type, we return specific properties of the
 set of generators via inquiry functions.  This is equivalent to using
 explicit representations of the generators.
 
 For easy access, the properties are hard-coded and selected via case
 expressions.
 
 Return true if the generator \#[[i]] is in the Cartan subalgebra,
 i.e., a diagonal matrix for spin type [[s]].
 <<su algebra: public>>=
   public :: is_cartan_generator
 <<su algebra: procedures>>=
   elemental function is_cartan_generator (s, i) result (cartan)
     logical :: cartan
     integer, intent(in) :: s, i
     select case (s)
     case (SCALAR)
     case (SPINOR)
        select case (i)
        case (3);  cartan = .true.
        case default
           cartan = .false.
        end select
     case (VECTOR)
        select case (i)
        case (3,8);  cartan = .true.
        case default
           cartan = .false.
        end select
     case (VECTORSPINOR)
        select case (i)
        case (3,6,15);  cartan = .true.
        case default
           cartan = .false.
        end select
     case (TENSOR)
        select case (i)
        case (3,6,15,24);  cartan = .true.
        case default
           cartan = .false.
        end select
     case default
        cartan = .false.
     end select
   end function is_cartan_generator
 
 @ %def is_cartan_generator
 @ Return the index of Cartan generator \#[[k]] in the chosen
 representation.  This has to conform to [[cartan]] above.
 <<su algebra: public>>=
   public :: cartan_index
 <<su algebra: procedures>>=
   elemental function cartan_index (s, k) result (ci)
     integer :: ci
     integer, intent(in) :: s, k
     integer, dimension(1), parameter :: ci2 = [3]
     integer, dimension(2), parameter :: ci3 = [3,8]
     integer, dimension(3), parameter :: ci4 = [3,6,15]
     integer, dimension(4), parameter :: ci5 = [3,6,15,24]
     select case (s)
     case (SPINOR)
        ci = ci2(k)
     case (VECTOR)
        ci = ci3(k)
     case (VECTORSPINOR)
        ci = ci4(k)
     case (TENSOR)
        ci = ci5(k)
     case default
        ci = 0
     end select
   end function cartan_index
 
 @ %def cartan_index
 @ The element \#[[k]] of the result vector [[a]] is equal to the
 $(h,h)$ diagonal entry of the generator matrix $T^k$.  That is,
 evaluating this for all allowed values of [[h]], we recover the set of
 Cartan generator matrices.
 <<su algebra: public>>=
   public :: cartan_element
 <<su algebra: procedures>>=
   function cartan_element (s, h) result (a)
     real(default), dimension(:), allocatable :: a
     integer, intent(in) :: s, h
     real(default), parameter :: sqrt2 = sqrt (2._default)
     real(default), parameter :: sqrt3 = sqrt (3._default)
     real(default), parameter :: sqrt10 = sqrt (10._default)
     allocate (a (algebra_dimension (s)), source = 0._default)
     select case (s)
     case (SCALAR)
     case (SPINOR)
        select case (h)
        case (1)
           a(3) =  1._default / 2
        case (-1)
           a(3) = -1._default / 2
        end select
     case (VECTOR)
        select case (h)
        case (1)
           a(3) =  1._default / 2
           a(8) =  1._default / (2 * sqrt3)
        case (-1)
           a(3) = -1._default / 2
           a(8) =  1._default / (2 * sqrt3)
        case (0)
           a(8) = -1._default / sqrt3
        end select
     case (VECTORSPINOR)
        select case (h)
        case (2)
           a(3)  =  1._default / 2
           a(15) =  1._default / (2 * sqrt2)
        case (-2)
           a(3)  = -1._default / 2
           a(15) =  1._default / (2 * sqrt2)
        case (1)
           a(6)  =  1._default / 2
           a(15) = -1._default / (2 * sqrt2)
        case (-1)
           a(6)  = -1._default / 2
           a(15) = -1._default / (2 * sqrt2)
        end select
     case (TENSOR)
        select case (h)
        case (2)
           a(3)  =  1._default / 2
           a(15) =  1._default / (2 * sqrt2)
           a(24) =  1._default / (2 * sqrt10)
        case (-2)
           a(3)  = -1._default / 2
           a(15) =  1._default / (2 * sqrt2)
           a(24) =  1._default / (2 * sqrt10)
        case (1)
           a(6)  =  1._default / 2
           a(15) = -1._default / (2 * sqrt2)
           a(24) =  1._default / (2 * sqrt10)
        case (-1)
           a(6)  = -1._default / 2
           a(15) = -1._default / (2 * sqrt2)
           a(24) =  1._default / (2 * sqrt10)
        case (0)
           a(24) = -4._default / (2 * sqrt10)
        end select
     end select
   end function cartan_element
 
 @ %def cartan_element
 @ Given an array of diagonal matrix elements [[rd]] of a generator,
 compute the array [[a]] of basis coefficients.  The array must be
 ordered as defined by [[helicity_value]], i.e., highest weight first.
 The calculation is organized such that the trace of the generator,
 i.e., the sum of [[rd]] values, drops out.  The result array [[a]] has
 coefficients for all basis generators, but only Cartan generators can
 get a nonzero coefficient.
 <<su algebra: public>>=
   public :: cartan_coeff
 <<su algebra: procedures>>=
   function cartan_coeff (s, rd) result (a)
     real(default), dimension(:), allocatable :: a
     integer, intent(in) :: s
     real(default), dimension(:), intent(in) :: rd
     real(default), parameter :: sqrt2 = sqrt (2._default)
     real(default), parameter :: sqrt3 = sqrt (3._default)
     real(default), parameter :: sqrt10 = sqrt (10._default)
     integer :: n
     n = algebra_dimension (s)
     allocate (a (n), source = 0._default)
     select case (s)
     case (SPINOR)
        a(3) = rd(1) - rd(2)
     case (VECTOR)
        a(3) = rd(1) - rd(3)
        a(8) = (rd(1) - 2 * rd(2) + rd(3)) / sqrt3
     case (VECTORSPINOR)
        a(3) = rd(1) - rd(4)
        a(6) = rd(2) - rd(3)
        a(15) = (rd(1) - rd(2) - rd(3) + rd(4)) / sqrt2
     case (TENSOR)
        a(3) = rd(1) - rd(5)
        a(6) = rd(2) - rd(4)
        a(15) = (rd(1) - rd(2) - rd(4) + rd(5)) / sqrt2
        a(24) = (rd(1) + rd(2) - 4 * rd(3) + rd(4) + rd(5)) / sqrt10
     end select
   end function cartan_coeff
 
 @ %def cartan_coeff
 @
 \subsection{Roots (Off-Diagonal Generators)}
 Return the appropriate generator index for a given off-diagonal helicity
 combination.  We require $h_1>h_2$.  We return the index of the
 appropriate real-valued generator if [[r]] is true, else the
 complex-valued one.
 
 This is separate from the [[cartan_coeff]] function above.  The reason
 is that the off-diagonal generators have only a single nonzero matrix
 element, so there is a one-to-one correspondence of helicity and index.
 <<su algebra: public>>=
   public :: root_index
 <<su algebra: procedures>>=
   function root_index (s, h1, h2, r) result (ai)
     integer :: ai
     integer, intent(in) :: s, h1, h2
     logical :: r
     ai = 0
     select case (s)
     case (SCALAR)
     case (SPINOR)
        select case (h1)
        case (1)
           select case (h2)
           case (-1);  ai = 1
           end select
        end select
     case (VECTOR)
        select case (h1)
        case (1)
           select case (h2)
           case (-1);  ai = 1
           case (0);   ai = 4
           end select
        case (0)
           select case (h2)
           case (-1);  ai = 6
           end select
        end select
     case (VECTORSPINOR)
        select case (h1)
        case (2)
           select case (h2)
           case (-2);  ai = 1
           case (1);   ai = 7
           case (-1);  ai = 11
           end select
        case (1)
           select case (h2)
           case (-1);  ai = 4
           case (-2);  ai = 13
           end select
        case (-1)
           select case (h2)
           case (-2);  ai = 9
           end select
        end select
     case (TENSOR)
        select case (h1)
        case (2)
           select case (h2)
           case (-2);  ai = 1
           case (1);   ai = 7
           case (-1);  ai = 11
           case (0);   ai = 16
           end select
        case (1)
           select case (h2)
           case (-1);  ai = 4
           case (-2);  ai = 13
           case (0);   ai = 20
           end select
        case (-1)
           select case (h2)
           case (-2);  ai = 9
           end select
        case (0)
           select case (h2)
           case (-2);  ai = 18
           case (-1);  ai = 22
           end select
        end select
     end select
     if (ai /= 0 .and. .not. r)  ai = ai + 1
   end function root_index
 
 @ %def root_index
 @ Inverse: return the helicity values ($h_2>h_1$) for an off-diagonal
 generator.  The flag [[r]] tells whether this is a real or diagonal
 generator.   The others are Cartan generators.
 <<su algebra: public>>=
   public :: root_helicity
 <<su algebra: procedures>>=
   subroutine root_helicity (s, i, h1, h2, r)
     integer, intent(in) :: s, i
     integer, intent(out) :: h1, h2
     logical, intent(out) :: r
     h1 = 0
     h2 = 0
     r  = .false.
     select case (s)
     case (SCALAR)
     case (SPINOR)
        select case (i)
        case ( 1, 2);  h1 =  1;  h2 = -1;  r = i == 1
        end select
     case (VECTOR)
        select case (i)
        case ( 1, 2);  h1 =  1;  h2 = -1;  r = i == 1
        case ( 4, 5);  h1 =  1;  h2 =  0;  r = i == 4
        case ( 6, 7);  h1 =  0;  h2 = -1;  r = i == 6
        end select
     case (VECTORSPINOR)
        select case (i)
        case ( 1, 2);  h1 =  2;  h2 = -2;  r = i == 1
        case ( 4, 5);  h1 =  1;  h2 = -1;  r = i == 4
        case ( 7, 8);  h1 =  2;  h2 =  1;  r = i == 7
        case ( 9,10);  h1 = -1;  h2 = -2;  r = i == 9
        case (11,12);  h1 =  2;  h2 = -1;  r = i ==11
        case (13,14);  h1 =  1;  h2 = -2;  r = i ==13
        end select
     case (TENSOR)
        select case (i)
        case ( 1, 2);  h1 =  2;  h2 = -2;  r = i == 1
        case ( 4, 5);  h1 =  1;  h2 = -1;  r = i == 4
        case ( 7, 8);  h1 =  2;  h2 =  1;  r = i == 7
        case ( 9,10);  h1 = -1;  h2 = -2;  r = i == 9
        case (11,12);  h1 =  2;  h2 = -1;  r = i ==11
        case (13,14);  h1 =  1;  h2 = -2;  r = i ==13
        case (16,17);  h1 =  2;  h2 =  0;  r = i ==16
        case (18,19);  h1 =  0;  h2 = -2;  r = i ==18
        case (20,21);  h1 =  1;  h2 =  0;  r = i ==20
        case (22,23);  h1 =  0;  h2 = -1;  r = i ==22
        end select
     end select
   end subroutine root_helicity
 
 @ %def root_helicity
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[su_algebra_ut.f90]]>>=
 <<File header>>
 
 module su_algebra_ut
   use unit_tests
   use su_algebra_uti
 
 <<Standard module head>>
 
 <<su algebra: public test>>
 
 contains
 
 <<su algebra: test driver>>
 
 end module su_algebra_ut
 @ %def su_algebra_ut
 @
 <<[[su_algebra_uti.f90]]>>=
 <<File header>>
 
 module su_algebra_uti
 
 <<Use kinds>>
   use physics_defs, only: SCALAR, SPINOR, VECTOR, VECTORSPINOR, TENSOR
   use su_algebra
 
 <<Standard module head>>
 
 <<su algebra: test declarations>>
 
 contains
 
 <<su algebra: tests>>
 
 end module su_algebra_uti
 @ %def su_algebra_ut
 @ API: driver for the unit tests below.
 <<su algebra: public test>>=
   public :: su_algebra_test
 <<su algebra: test driver>>=
   subroutine su_algebra_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<su algebra: execute tests>>
   end subroutine su_algebra_test
 
 @  %def su_algebra_test
 @
 \subsubsection{Generator Ordering}
 Show the position of Cartan generators in the sequence of basis generators.
 <<su algebra: execute tests>>=
   call test (su_algebra_1, "su_algebra_1", &
        "generator ordering", &
        u, results)
 <<su algebra: test declarations>>=
   public :: su_algebra_1
 <<su algebra: tests>>=
   subroutine su_algebra_1 (u)
     integer, intent(in) :: u
 
     write (u, "(A)")  "* Test output: su_algebra_1"
     write (u, "(A)")  "*   Purpose: test su(N) algebra implementation"
     write (u, "(A)")
 
     write (u, "(A)")  "* su(N) generators: &
          &list and mark Cartan subalgebra"
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 0"
     call cartan_check (SCALAR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1/2"
     call cartan_check (SPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1"
     call cartan_check (VECTOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 3/2"
     call cartan_check (VECTORSPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 2"
     call cartan_check (TENSOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: su_algebra_1"
 
   contains
 
     subroutine cartan_check (s)
       integer, intent(in) :: s
       integer :: i
       write (u, *)
       do i = 1, algebra_dimension (s)
          write (u, "(1x,L1)", advance="no")  is_cartan_generator (s, i)
       end do
       write (u, *)
 
     end subroutine cartan_check
 
   end subroutine su_algebra_1
 
 @ %def su_algebra_1
 @
 \subsubsection{Cartan Generator Basis}
 Show the explicit matrix representation for all Cartan generators and
 check their traces and Killing products.
 
 Also test helicity index mappings.
 <<su algebra: execute tests>>=
   call test (su_algebra_2, "su_algebra_2", &
        "Cartan generator representation", &
        u, results)
 <<su algebra: test declarations>>=
   public :: su_algebra_2
 <<su algebra: tests>>=
   subroutine su_algebra_2 (u)
     integer, intent(in) :: u
 
     write (u, "(A)")  "* Test output: su_algebra_2"
     write (u, "(A)")  "*   Purpose: test su(N) algebra implementation"
     write (u, "(A)")
 
     write (u, "(A)")  "* diagonal su(N) generators: &
          &show explicit representation"
     write (u, "(A)")  "* and check trace and Killing form"
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1/2"
     call cartan_show (SPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1"
     call cartan_show (VECTOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 3/2"
     call cartan_show (VECTORSPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 2"
     call cartan_show (TENSOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: su_algebra_2"
 
   contains
 
     subroutine cartan_show (s)
       integer, intent(in) :: s
       real(default), dimension(:,:), allocatable :: rd
       integer, dimension(:), allocatable :: ci
       integer :: n, d, h, i, j, k, l
 
       n = algebra_dimension (s)
       d = fundamental_dimension (s)
 
       write (u, *)
       write (u, "(A2,5X)", advance="no")  "h:"
       do i = 1, d
          j = helicity_index (s, helicity_value (s, i))
          write (u, "(1x,I2,5X)", advance="no")  helicity_value (s, j)
       end do
       write (u, "(8X)", advance="no")
       write (u, "(1X,A)")  "tr"
 
       allocate (rd (n,d), source = 0._default)
       do i = 1, d
          h = helicity_value (s, i)
          rd(:,i) = cartan_element (s, h)
       end do
 
       allocate (ci (d-1), source = 0)
       do k = 1, d-1
          ci(k) = cartan_index (s, k)
       end do
 
       write (u, *)
       do k = 1, d-1
          write (u, "('T',I2,':',1X)", advance="no")  ci(k)
          do i = 1, d
             write (u, 1, advance="no")  rd(ci(k),i)
          end do
          write (u, "(8X)", advance="no")
          write (u, 1)  sum (rd(ci(k),:))
       end do
 
       write (u, *)
       write (u, "(6X)", advance="no")
       do k = 1, d-1
          write (u, "(2X,'T',I2,3X)", advance="no")  ci(k)
       end do
       write (u, *)
 
       do k = 1, d-1
          write (u, "('T',I2,2X)", advance="no")  ci(k)
          do l = 1, d-1
             write (u, 1, advance="no")  dot_product (rd(ci(k),:), rd(ci(l),:))
          end do
          write (u, *)
       end do
 
 1     format (1x,F7.4)
 
     end subroutine cartan_show
 
   end subroutine su_algebra_2
 
 @ %def su_algebra_2
 @
 \subsubsection{Bloch Representation: Cartan Generators}
 Transform from Bloch vectors to matrix and back, considering Cartan
 generators only.
 <<su algebra: execute tests>>=
   call test (su_algebra_3, "su_algebra_3", &
        "Cartan generator mapping", &
        u, results)
 <<su algebra: test declarations>>=
   public :: su_algebra_3
 <<su algebra: tests>>=
   subroutine su_algebra_3 (u)
     integer, intent(in) :: u
 
     write (u, "(A)")  "* Test output: su_algebra_3"
     write (u, "(A)")  "*   Purpose: test su(N) algebra implementation"
     write (u, "(A)")
 
     write (u, "(A)")  "* diagonal su(N) generators: &
          &transform to matrix and back"
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1/2"
     call cartan_expand (SPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1"
     call cartan_expand (VECTOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 3/2"
     call cartan_expand (VECTORSPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 2"
     call cartan_expand (TENSOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: su_algebra_3"
 
   contains
 
     subroutine cartan_expand (s)
       integer, intent(in) :: s
       real(default), dimension(:,:), allocatable :: rd
       integer, dimension(:), allocatable :: ci
       real(default), dimension(:), allocatable :: a
       logical, dimension(:), allocatable :: mask
       integer :: n, d, h, i, k, l
 
       n = algebra_dimension (s)
       d = fundamental_dimension (s)
 
       allocate (rd (n,d), source = 0._default)
       do i = 1, d
          h = helicity_value (s, i)
          rd(:,i) = cartan_element (s, h)
       end do
 
       allocate (ci (d-1), source = 0)
       do k = 1, d-1
          ci(k) = cartan_index (s, k)
       end do
 
       allocate (a (n))
 
       write (u, *)
       do k = 1, d-1
          a(:) = cartan_coeff (s, rd(ci(k),:))
          write (u, "('T',I2,':',1X)", advance="no")  ci(k)
          do i = 1, n
             if (is_cartan_generator (s, i)) then
                write (u, 1, advance="no")  a(i)
             else if (a(i) /= 0) then
                ! this should not happen (nonzero non-Cartan entry)
                write (u, "(1X,':',I2,':',3X)", advance="no")  i
             end if
          end do
          write (u, *)
       end do
 
 1     format (1X,F7.4)
 
     end subroutine cartan_expand
 
   end subroutine su_algebra_3
 
 @ %def su_algebra_3
 @
 \subsubsection{Bloch Representation: Roots}
 List the mapping between helicity transitions and (real) off-diagonal
 generators.
 <<su algebra: execute tests>>=
   call test (su_algebra_4, "su_algebra_4", &
        "Root-helicity mapping", &
        u, results)
 <<su algebra: test declarations>>=
   public :: su_algebra_4
 <<su algebra: tests>>=
   subroutine su_algebra_4 (u)
     integer, intent(in) :: u
 
     write (u, "(A)")  "* Test output: su_algebra_4"
     write (u, "(A)")  "*   Purpose: test su(N) algebra implementation"
     write (u, "(A)")
 
     write (u, "(A)")  "* off-diagonal su(N) generators: &
          &mapping from/to helicity pair"
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1/2"
     call root_expand (SPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1"
     call root_expand (VECTOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 3/2"
     call root_expand (VECTORSPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 2"
     call root_expand (TENSOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: su_algebra_4"
 
   contains
 
     subroutine root_expand (s)
       integer, intent(in) :: s
       integer :: n, d, i, j, h1, h2
       logical :: r
 
       n = algebra_dimension (s)
 
       write (u, *)
       do i = 1, n
          if (is_cartan_generator (s, i))  cycle
          call root_helicity (s, i, h1, h2, r)
          j = root_index (s, h1, h2, r)
          write (u, "('T',I2,':')", advance="no")  j
          write (u, "(2(1x,I2))", advance="no")  h1, h2
          if (r) then
             write (u, *)
          else
             write (u, "('*')")
          end if
       end do
 
     end subroutine root_expand
 
   end subroutine su_algebra_4
 
 @ %def su_algebra_4
 @
 \clearpage
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Bloch Representation}
 Particle polarization is determined by a particular quantum state
 which has just helicity information.  Physically, this is the spin
 density matrix $\rho$, where we do not restrict ourselves to pure
 states.
 
 We adopt the phase convention for a spin-1/2 particle that
 \begin{equation}
   \rho = \tfrac12(1 + \vec\alpha\cdot\vec\sigma)
 \end{equation}
 with the polarization axis $\vec\alpha$.  For a particle with
 arbitrary spin $s$, and thus $N=2s+1$ spin states, we extend the above
 definition to generalized Bloch form
 \begin{equation}
   \rho = \frac1N\left(1 + \sqrt{2N(N-1)}\alpha^aT^a\right)
 \end{equation}
 where the $T^a$ ($a=1,\ldots N^2-1$) are a basis of $su(N)$ algebra
 generators.  These $N\times N$ matrices are hermitean, traceless, and
 orthogonal via
 \begin{equation}
   \mathop{\rm Tr}T^aT^b = \frac12 \delta^{ab}
 \end{equation}
 In the spin-1/2 case, this reduces to the above (standard Bloch)
 representation since $T^a = \sigma^a/2$, $a=1,2,3$.  For the spin-1
 case, we could use $T^a = \lambda^a/2$ with the Gell-Mann matrices,
 \begin{equation}
   \rho = \frac13\left(1 + \sqrt{3}\alpha^a\lambda^a\right),
 \end{equation}
 The normalization is chosen that $|alpha|\leq 1$ for allowed density
 matrix, where $|\alpha|=1$ is a necessary, but not sufficient,
 condition for a pure state.
 
 We need a specific choice of basis for a well-defined component
 representation.  The matrix elements of $T^a$ are
 ordered as $m=\ell,\ell-1,\ldots -\ell$, i.e., from highest down to
 lowest weight, for both row and column.
 
 We list first the generators of the $su(2)$ subalgebras which leave
 $|m|$ invariant ($|m|\neq 0$):
 \begin{equation}
   T^{b+1,b+2,b+3} \equiv \sigma^{1,2,3}
 \end{equation}
 acting on the respective subspace $|m|=\ell,\ell-1,\ldots$ for
 $b=0,1,\ldots$.  This defines generators $T^a$ for $a=1,\ldots 3N/2$
 ($\ldots 3(N-1)/2$) for $N$ even (odd), respectively.
 
 The following generators successively extend this to $su(4)$, $su(6)$,
 \ldots until $su(N)$ by adding first the missing off-diagonal and then
 diagonal generators.  The phase conventions are analogous.
 
 (It should be possible to code these conventions for generic spin, but
 in the current implementation we restrict ourselves to $s\leq 2$, i.e.,
 $N\leq 5$.)
 
 Particle polarization is determined by a particular quantum state
 which has just helicity information.  Physically, this is the spin
 density matrix $\rho$, where we do not restrict ourselves to pure
 states.
 
 We adopt the phase convention for a spin-1/2 particle that
 \begin{equation}
   \rho = \tfrac12(1 + \vec\alpha\cdot\vec\sigma)
 \end{equation}
 with the polarization axis $\vec\alpha$.  For a particle with
 arbitrary spin $s$, and thus $N=2s+1$ spin states, we extend the above
 definition to generalized Bloch form
 \begin{equation}
   \rho = \frac1N\left(1 + \sqrt{2N(N-1)}\alpha^aT^a\right)
 \end{equation}
 where the $T^a$ ($a=1,\ldots N^2-1$) are a basis of $su(N)$ algebra
 generators.  These $N\times N$ matrices are hermitean, traceless, and
 orthogonal via
 \begin{equation}
   \mathop{\rm Tr}T^aT^b = \frac12 \delta^{ab}
 \end{equation}
 In the spin-1/2 case, this reduces to the above (standard Bloch)
 representation since $T^a = \sigma^a/2$, $a=1,2,3$.  For the spin-1
 case, we could use $T^a = \lambda^a/2$ with the Gell-Mann matrices,
 \begin{equation}
   \rho = \frac13\left(1 + \sqrt{3}\alpha^a\lambda^a\right),
 \end{equation}
 The normalization is chosen that $|alpha|\leq 1$ for allowed density
 matrix, where $|\alpha|=1$ is a necessary, but not sufficient,
 condition for a pure state.
 <<[[bloch_vectors.f90]]>>=
 <<File header>>
 
 module bloch_vectors
 
 <<Use kinds>>
   use physics_defs, only: UNKNOWN, SCALAR, SPINOR, VECTOR, VECTORSPINOR, TENSOR
   use su_algebra
 
 <<Standard module head>>
 
 <<Bloch vectors: public>>
 
 <<Bloch vectors: types>>
 
 contains
 
 <<Bloch vectors: procedures>>
 
 end module bloch_vectors
 @ %def bloch_vectors
 @
 \subsection{Preliminaries}
 The normalization factor $\sqrt{2N(N-1)}/N$ that enters the Bloch
 representation.
 <<Bloch vectors: procedures>>=
   function bloch_factor (s) result (f)
     real(default) :: f
     integer, intent(in) :: s
     select case (s)
     case (SCALAR)
        f = 0
     case (SPINOR)
        f = 1
     case (VECTOR)
        f = 2 * sqrt (3._default) / 3
     case (VECTORSPINOR)
        f = 2 * sqrt (6._default) / 4
     case (TENSOR)
        f = 2 * sqrt (10._default) / 5
     case default
        f = 0
     end select
   end function bloch_factor
 
 @ %def bloch_factor
 @
 \subsection{The basic polarization type}
 The basic polarization object holds just the entries of the Bloch
 vector as an allocatable array.
 
 Bloch is active whenever the coefficient array is allocated.
 For convenience, we store the spin type ($2s$) and the multiplicity
 ($N$) together with the coefficient array ($\alpha$).  We have to allow for
 the massless case where $s$ is arbitrary $>0$ but $N=2$, and
 furthermore the chiral massless case where $N=1$.  In the latter case,
 the array remains deallocated but the chirality is set to $\pm 1$.
 
 In the Bloch vector implementation, we do not distinguish between
 particle and antiparticle.  If the distinction applies, it must be
 made by the caller when transforming between density matrix and Bloch vector.
 <<Bloch vectors: public>>=
   public :: bloch_vector_t
 <<Bloch vectors: types>>=
   type :: bloch_vector_t
      private
      integer :: spin_type = UNKNOWN
      real(default), dimension(:), allocatable :: a
    contains
    <<Bloch vectors: bloch vector: TBP>>
 end type bloch_vector_t
 
 @ %def bloch_vector_t
 @
 \subsection{Direct Access}
 This basic initializer just sets the spin type, leaving the Bloch vector
 unallocated.  The object therefore does not support nonzero polarization.
 <<Bloch vectors: bloch vector: TBP>>=
   procedure :: init_unpolarized => bloch_vector_init_unpolarized
 <<Bloch vectors: procedures>>=
   subroutine bloch_vector_init_unpolarized (pol, spin_type)
     class(bloch_vector_t), intent(out) :: pol
     integer, intent(in) :: spin_type
     pol%spin_type = spin_type
   end subroutine bloch_vector_init_unpolarized
 
 @ %def bloch_vector_init_unpolarized
 @ The standard initializer allocates the Bloch vector and initializes
 with zeros, so we can define a polarization later.  We make sure that
 this works only for the supported spin type.  Initializing with
 [[UNKNOWN]] spin type resets the Bloch vector to undefined, i.e.,
 unpolarized state.
 <<Bloch vectors: bloch vector: TBP>>=
   generic :: init => bloch_vector_init
   procedure, private :: bloch_vector_init
 <<Bloch vectors: procedures>>=
   subroutine bloch_vector_init (pol, spin_type)
     class(bloch_vector_t), intent(out) :: pol
     integer, intent(in) :: spin_type
     pol%spin_type = spin_type
     select case (spin_type)
     case (SCALAR,SPINOR,VECTOR,VECTORSPINOR,TENSOR)
        allocate (pol%a (algebra_dimension (spin_type)), source = 0._default)
     end select
   end subroutine bloch_vector_init
 
 @ %def bloch_vector_init
 @
 Fill the Bloch vector from an array, no change of normalization.  No
 initialization and no check, we assume that the shapes do match.
 <<Bloch vectors: bloch vector: TBP>>=
   procedure :: from_array => bloch_vector_from_array
 <<Bloch vectors: procedures>>=
   subroutine bloch_vector_from_array (pol, a)
     class(bloch_vector_t), intent(inout) :: pol
     real(default), dimension(:), allocatable, intent(in) :: a
     pol%a(:) = a
   end subroutine bloch_vector_from_array
 
 @ %def bloch_vector_from_array
 @
 Transform to an array of reals, i.e., extract the Bloch vector as-is.
 <<Bloch vectors: bloch vector: TBP>>=
   procedure :: to_array => bloch_vector_to_array
 <<Bloch vectors: procedures>>=
   subroutine bloch_vector_to_array (pol, a)
     class(bloch_vector_t), intent(in) :: pol
     real(default), dimension(:), allocatable, intent(out) :: a
     if (pol%is_defined ())  allocate (a (size (pol%a)), source = pol%a)
   end subroutine bloch_vector_to_array
 
 @ %def bloch_vector_to_array
 @
 \subsection{Raw I/O}
 <<Bloch vectors: bloch vector: TBP>>=
   procedure :: write_raw => bloch_vector_write_raw
   procedure :: read_raw => bloch_vector_read_raw
 <<Bloch vectors: procedures>>=
   subroutine bloch_vector_write_raw (pol, u)
     class(bloch_vector_t), intent(in) :: pol
     integer, intent(in) :: u
     write (u) pol%spin_type
     write (u) allocated (pol%a)
     if (allocated (pol%a)) then
        write (u) pol%a
     end if
   end subroutine bloch_vector_write_raw
 
   subroutine bloch_vector_read_raw (pol, u, iostat)
     class(bloch_vector_t), intent(out) :: pol
     integer, intent(in) :: u
     integer, intent(out) :: iostat
     integer :: s
     logical :: polarized
     read (u, iostat=iostat) s
     read (u, iostat=iostat) polarized
     if (iostat /= 0)  return
     if (polarized) then
        call pol%init (s)
        read (u, iostat=iostat) pol%a
     else
        call pol%init_unpolarized (s)
     end if
   end subroutine bloch_vector_read_raw
 
 @ %def bloch_vector_write_raw
 @ %def bloch_vector_read_raw
 @
 \subsection{Properties}
 Re-export algebra functions that depend on the spin type.  These
 functions do not depend on the Bloch vector being allocated.
 <<Bloch vectors: bloch vector: TBP>>=
   procedure :: get_n_states
   procedure :: get_length
   procedure :: hel_index => bv_helicity_index
   procedure :: hel_value => bv_helicity_value
   procedure :: bloch_factor => bv_factor
 <<Bloch vectors: procedures>>=
   function get_n_states (pol) result (n)
     class(bloch_vector_t), intent(in) :: pol
     integer :: n
     n = fundamental_dimension (pol%spin_type)
   end function get_n_states
 
   function get_length (pol) result (n)
     class(bloch_vector_t), intent(in) :: pol
     integer :: n
     n = algebra_dimension (pol%spin_type)
   end function get_length
 
   function bv_helicity_index (pol, h) result (i)
     class(bloch_vector_t), intent(in) :: pol
     integer, intent(in) :: h
     integer :: i
     i = helicity_index (pol%spin_type, h)
   end function bv_helicity_index
 
   function bv_helicity_value (pol, i) result (h)
     class(bloch_vector_t), intent(in) :: pol
     integer, intent(in) :: i
     integer :: h
     h = helicity_value (pol%spin_type, i)
   end function bv_helicity_value
 
   function bv_factor (pol) result (f)
     class(bloch_vector_t), intent(in) :: pol
     real(default) :: f
     f = bloch_factor (pol%spin_type)
   end function bv_factor
 
 @ %def get_n_states
 @ %def helicity_index
 @ %def helicity_value
 @ If the Bloch vector object is defined, the spin type is anything else but
 [[UNKNOWN]].  This allows us the provide the representation-specific
 functions above.
 <<Bloch vectors: bloch vector: TBP>>=
   procedure :: is_defined => bloch_vector_is_defined
 <<Bloch vectors: procedures>>=
   function bloch_vector_is_defined (pol) result (flag)
     class(bloch_vector_t), intent(in) :: pol
     logical :: flag
     flag = pol%spin_type /= UNKNOWN
   end function bloch_vector_is_defined
 
 @ %def bloch_vector_is_defined
 @ If the Bloch vector object is (technically) polarized, it is
 defined, and the vector coefficient array has been allocated.
 However, the vector value may be zero.
 <<Bloch vectors: bloch vector: TBP>>=
   procedure :: is_polarized => bloch_vector_is_polarized
 <<Bloch vectors: procedures>>=
   function bloch_vector_is_polarized (pol) result (flag)
     class(bloch_vector_t), intent(in) :: pol
     logical :: flag
     flag = allocated (pol%a)
   end function bloch_vector_is_polarized
 
 @ %def bloch_vector_is_polarized
 @ Return true if the polarization is diagonal, i.e., all entries in
 the density matrix are on the diagonal.  This is equivalent to
 requiring that only Cartan generator coefficients are nonzero in the
 Bloch vector.
 <<Bloch vectors: bloch vector: TBP>>=
   procedure :: is_diagonal => bloch_vector_is_diagonal
 <<Bloch vectors: procedures>>=
   function bloch_vector_is_diagonal (pol) result (diagonal)
     class(bloch_vector_t), intent(in) :: pol
     logical :: diagonal
     integer :: s, i
     s = pol%spin_type
     diagonal = .true.
     if (pol%is_polarized ()) then
        do i = 1, size (pol%a)
           if (is_cartan_generator (s, i))  cycle
           if (pol%a(i) /= 0) then
              diagonal = .false.
              return
           end if
        end do
     end if
   end function bloch_vector_is_diagonal
 
 @ %def bloch_vector_is_diagonal
 @
 Return the Euclidean norm of the Bloch vector.  This is equal to the
 Killing form value of the corresponding algebra generator.  We assume
 that the polarization object has been initialized.
 
 For a pure state, the norm is unity.  All other allowed states have a
 norm less than unity.  (For $s\geq 1$, this is a necessary but not
 sufficient condition.)
 <<Bloch vectors: bloch vector: TBP>>=
   procedure :: get_norm => bloch_vector_get_norm
 <<Bloch vectors: procedures>>=
   function bloch_vector_get_norm (pol) result (norm)
     class(bloch_vector_t), intent(in) :: pol
     real(default) :: norm
     select case (pol%spin_type)
     case (SPINOR,VECTOR,VECTORSPINOR,TENSOR)
        norm = sqrt (dot_product (pol%a, pol%a))
     case default
        norm = 1
     end select
   end function bloch_vector_get_norm
 
 @ %def bloch_vector_get_norm
 @
 \subsection{Diagonal density matrix}
 This initializer takes a diagonal density matrix, represented by a
 real-valued array.  We assume that the trace is unity, and that the
 array has the correct shape for the given [[spin_type]].
 
 The [[bloch_factor]] renormalization is necessary such that a pure
 state maps to a Bloch vector with unit norm.
 <<Bloch vectors: bloch vector: TBP>>=
   generic :: init => bloch_vector_init_diagonal
   procedure, private :: bloch_vector_init_diagonal
 <<Bloch vectors: procedures>>=
   subroutine bloch_vector_init_diagonal (pol, spin_type, rd)
     class(bloch_vector_t), intent(out) :: pol
     integer, intent(in) :: spin_type
     real(default), dimension(:), intent(in) :: rd
     call pol%init (spin_type)
     call pol%set (rd)
   end subroutine bloch_vector_init_diagonal
 
 @ %def bloch_vector_init_diagonal
 @ Set a Bloch vector, given a diagonal density matrix as a real array.
 The Bloch vector must be initialized with correct characteristics.
 <<Bloch vectors: bloch vector: TBP>>=
   generic :: set => bloch_vector_set_diagonal
   procedure, private :: bloch_vector_set_diagonal
 <<Bloch vectors: procedures>>=
   subroutine bloch_vector_set_diagonal (pol, rd)
     class(bloch_vector_t), intent(inout) :: pol
     real(default), dimension(:), intent(in) :: rd
     integer :: s
     s = pol%spin_type
     select case (s)
     case (SCALAR,SPINOR,VECTOR,VECTORSPINOR,TENSOR)
        pol%a(:) = cartan_coeff (s, rd) / bloch_factor (s)
     end select
   end subroutine bloch_vector_set_diagonal
 
 @ %def bloch_vector_set_diagonal
 @
 @
 \subsection{Massless density matrix}
 This is a specific variant which initializes an equipartition for
 the maximum helicity, corresponding to an unpolarized massless particle.
 <<Bloch vectors: bloch vector: TBP>>=
   procedure :: init_max_weight => bloch_vector_init_max_weight
 <<Bloch vectors: procedures>>=
   subroutine bloch_vector_init_max_weight (pol, spin_type)
     class(bloch_vector_t), intent(out) :: pol
     integer, intent(in) :: spin_type
     call pol%init (spin_type)
     select case (spin_type)
     case (VECTOR)
        call pol%set ([0.5_default, 0._default, 0.5_default])
     case (VECTORSPINOR)
        call pol%set ([0.5_default, 0._default, 0._default, 0.5_default])
     case (TENSOR)
        call pol%set ([0.5_default, 0._default, 0._default, 0._default, 0.5_default])
     end select
   end subroutine bloch_vector_init_max_weight
 
 @ %def bloch_vector_init_max_weight
 @ Initialize the maximum-weight submatrix with a three-component Bloch
 vector.  This is not as trivial as it seems because we need the above
 initialization for the generalized Bloch in order to remove the lower
 weights from the density matrix.
 <<Bloch vectors: bloch vector: TBP>>=
   procedure :: init_vector => bloch_vector_init_vector
   procedure :: to_vector => bloch_vector_to_vector
 <<Bloch vectors: procedures>>=
   subroutine bloch_vector_init_vector (pol, s, a)
     class(bloch_vector_t), intent(out) :: pol
     integer, intent(in) :: s
     real(default), dimension(3), intent(in) :: a
     call pol%init_max_weight (s)
     select case (s)
     case (SPINOR, VECTOR, VECTORSPINOR, TENSOR)
        pol%a(1:3) = a / bloch_factor (s)
     end select
   end subroutine bloch_vector_init_vector
 
   subroutine bloch_vector_to_vector (pol, a)
     class(bloch_vector_t), intent(in) :: pol
     real(default), dimension(3), intent(out) :: a
     integer :: s
     s = pol%spin_type
     select case (s)
     case (SPINOR, VECTOR, VECTORSPINOR, TENSOR)
        a = pol%a(1:3) * bloch_factor (s)
     case default
        a = 0
     end select
   end subroutine bloch_vector_to_vector
 
 @ %def bloch_vector_init_vector
 @ %def bloch_vector_to_vector
 @
 \subsection{Arbitrary density matrix}
 Initialize the Bloch vector from a density matrix.  We assume that the
 density is valid.  In particular, the shape should match, the matrix
 should be hermitian, and the trace should be unity.
 
 We first fill the diagonal, then add the off-diagonal parts.
 <<Bloch vectors: bloch vector: TBP>>=
   generic :: init => bloch_vector_init_matrix
   procedure, private :: bloch_vector_init_matrix
 <<Bloch vectors: procedures>>=
   subroutine bloch_vector_init_matrix (pol, spin_type, r)
     class(bloch_vector_t), intent(out) :: pol
     integer, intent(in) :: spin_type
     complex(default), dimension(:,:), intent(in) :: r
     select case (spin_type)
     case (SCALAR,SPINOR,VECTOR,VECTORSPINOR,TENSOR)
        call pol%init (spin_type)
        call pol%set (r)
     case default
        call pol%init (UNKNOWN)
     end select
   end subroutine bloch_vector_init_matrix
 
 @ %def bloch_vector_init_matrix
 @ Set a Bloch vector, given an arbitrary density matrix as a real
 array.  The Bloch vector must be initialized with correct
 characteristics.
 <<Bloch vectors: bloch vector: TBP>>=
   generic :: set => bloch_vector_set_matrix
   procedure, private :: bloch_vector_set_matrix
 <<Bloch vectors: procedures>>=
   subroutine bloch_vector_set_matrix (pol, r)
     class(bloch_vector_t), intent(inout) :: pol
     complex(default), dimension(:,:), intent(in) :: r
     real(default), dimension(:), allocatable :: rd
     integer :: s, d, i, j, h1, h2, ir, ii
     s = pol%spin_type
     select case (s)
     case (SCALAR,SPINOR,VECTOR,VECTORSPINOR,TENSOR)
        d = fundamental_dimension (s)
        allocate (rd (d))
        do i = 1, d
           rd(i) = r(i,i)
        end do
        call pol%set (rd)
        do i = 1, d
           h1 = helicity_value (s, i)
           do j = i+1, d
              h2 = helicity_value (s, j)
              ir = root_index (s, h1, h2, .true.)
              ii = root_index (s, h1, h2, .false.)
              pol%a(ir) = real (r(j,i) + r(i,j)) / bloch_factor (s)
              pol%a(ii) = aimag (r(j,i) - r(i,j)) / bloch_factor (s)
           end do
        end do
     end select
   end subroutine bloch_vector_set_matrix
 
 @ %def bloch_vector_set_matrix
 @ Allocate and fill the density matrix [[r]] (with the index ordering as
 defined in [[su_algebra]]) that corresponds to a given Bloch vector.
 
 If the optional [[only_max_weight]] is set, the resulting matrix has
 entries only for $\pm h_\text{max}$, as appropriate for a massless
 particle (for spin $\geq 1$).  Note that we always add the unit
 matrix, as this is part of the Bloch-vector definition.
 <<Bloch vectors: bloch vector: TBP>>=
   procedure :: to_matrix => bloch_vector_to_matrix
 <<Bloch vectors: procedures>>=
   subroutine bloch_vector_to_matrix (pol, r, only_max_weight)
     class(bloch_vector_t), intent(in) :: pol
     complex(default), dimension(:,:), intent(out), allocatable :: r
     logical, intent(in), optional :: only_max_weight
     integer :: d, s, h0, ng, ai, h, h1, h2, i, j
     logical :: is_real, only_max
     complex(default) :: val
     if (.not. pol%is_polarized ())  return
     s = pol%spin_type
     only_max = .false.
     select case (s)
     case (VECTOR, VECTORSPINOR, TENSOR)
        if (present (only_max_weight))  only_max = only_max_weight
     end select
     if (only_max) then
        ng = 2
        h0 = helicity_value (s, 1)
     else
        ng = algebra_dimension (s)
        h0 = 0
     end if
     d = fundamental_dimension (s)
     allocate (r (d, d), source = (0._default, 0._default))
     do i = 1, d
        h = helicity_value (s, i)
        if (abs (h) < h0)  cycle
        r(i,i) = 1._default / d &
             + dot_product (cartan_element (s, h), pol%a) * bloch_factor (s)
     end do
     do ai = 1, ng
        if (is_cartan_generator (s, ai))  cycle
        call root_helicity (s, ai, h1, h2, is_real)
        i = helicity_index (s, h1)
        j = helicity_index (s, h2)
        if (is_real) then
           val = cmplx (pol%a(ai) / 2 * bloch_factor (s), 0._default, &
                kind=default)
           r(i,j) = r(i,j) + val
           r(j,i) = r(j,i) + val
        else
           val = cmplx (0._default, pol%a(ai) / 2 * bloch_factor (s), &
                kind=default)
           r(i,j) = r(i,j) - val
           r(j,i) = r(j,i) + val
        end if
     end do
   end subroutine bloch_vector_to_matrix
 
 @ %def bloch_vector_to_matrix
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[bloch_vectors_ut.f90]]>>=
 <<File header>>
 
 module bloch_vectors_ut
   use unit_tests
   use bloch_vectors_uti
 
 <<Standard module head>>
 
 <<Bloch vectors: public test>>
 
 contains
 
 <<Bloch vectors: test driver>>
 
 end module bloch_vectors_ut
 @ %def bloch_vectors_ut
 @
 <<[[bloch_vectors_uti.f90]]>>=
 <<File header>>
 
 module bloch_vectors_uti
 
 <<Use kinds>>
   use physics_defs, only: UNKNOWN, SCALAR, SPINOR, VECTOR, VECTORSPINOR, TENSOR
   use su_algebra, only: algebra_dimension, fundamental_dimension, helicity_value
 
   use bloch_vectors
 
 <<Standard module head>>
 
 <<Bloch vectors: test declarations>>
 
 contains
 
 <<Bloch vectors: tests>>
 
 end module bloch_vectors_uti
 @ %def bloch_vectors_ut
 @ API: driver for the unit tests below.
 <<Bloch vectors: public test>>=
   public :: bloch_vectors_test
 <<Bloch vectors: test driver>>=
   subroutine bloch_vectors_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Bloch vectors: execute tests>>
   end subroutine bloch_vectors_test
 
 @  %def bloch_vectors_test
 @
 \subsubsection{Initialization}
 Initialize the Bloch vector for any spin type.  First as unpolarized
 (no array), then as polarized but with zero polarization.
 <<Bloch vectors: execute tests>>=
   call test (bloch_vectors_1, "bloch_vectors_1", &
        "initialization", &
        u, results)
 <<Bloch vectors: test declarations>>=
   public :: bloch_vectors_1
 <<Bloch vectors: tests>>=
   subroutine bloch_vectors_1 (u)
     integer, intent(in) :: u
 
     write (u, "(A)")  "* Test output: bloch_vectors_1"
     write (u, "(A)")  "*   Purpose: test Bloch-vector &
          &polarization implementation"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialization (unpolarized)"
 
     write (u, "(A)")
     write (u, "(A)")  "* unknown"
     call bloch_init (UNKNOWN)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 0"
     call bloch_init (SCALAR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1/2"
     call bloch_init (SPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1"
     call bloch_init (VECTOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 3/2"
     call bloch_init (VECTORSPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 2"
     call bloch_init (TENSOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: bloch_vectors_1"
 
   contains
 
     subroutine bloch_init (s)
       integer, intent(in) :: s
       type(bloch_vector_t) :: pol
       real(default), dimension(:), allocatable :: a
       integer :: i
       write (u, *)
       write (u, "(1X,L1,L1)", advance="no") &
            pol%is_defined (), pol%is_polarized ()
       call pol%init_unpolarized (s)
       write (u, "(1X,L1,L1)", advance="no") &
            pol%is_defined (), pol%is_polarized ()
       call pol%init (s)
       write (u, "(1X,L1,L1)", advance="no") &
            pol%is_defined (), pol%is_polarized ()
       write (u, *)
       call pol%to_array (a)
       if (allocated (a)) then
          write (u, "(*(F7.4))")  a
          a(:) = [(real (mod (i, 10), kind=default), i = 1, size (a))]
          call pol%from_array (a)
          call pol%to_array (a)
          write (u, "(*(F7.4))")  a
       else
          write (u, *)
          write (u, *)
       end if
     end subroutine bloch_init
 
   end subroutine bloch_vectors_1
 
 @ %def bloch_vectors_1
 @
 \subsubsection{Pure state (diagonal)}
 Initialize the Bloch vector with a pure state of definite helicity and
 check the normalization.
 <<Bloch vectors: execute tests>>=
   call test (bloch_vectors_2, "bloch_vectors_2", &
        "pure state (diagonal)", &
        u, results)
 <<Bloch vectors: test declarations>>=
   public :: bloch_vectors_2
 <<Bloch vectors: tests>>=
   subroutine bloch_vectors_2 (u)
     integer, intent(in) :: u
 
     write (u, "(A)")  "* Test output: bloch_vectors_2"
     write (u, "(A)")  "*   Purpose: test Bloch-vector &
          &polarization implementation"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialization (polarized, diagonal): &
          &display vector and norm"
     write (u, "(A)")  "*   transform back"
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 0"
     call bloch_diagonal (SCALAR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1/2"
     call bloch_diagonal (SPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1"
     call bloch_diagonal (VECTOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 3/2"
     call bloch_diagonal (VECTORSPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 2"
     call bloch_diagonal (TENSOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: bloch_vectors_2"
 
   contains
 
     subroutine bloch_diagonal (s)
       integer, intent(in) :: s
       type(bloch_vector_t) :: pol
       real(default), dimension(:), allocatable :: a
       real(default), dimension(:), allocatable :: rd
       complex(default), dimension(:,:), allocatable :: r
       integer :: i, j, d
       real(default) :: rj
       real, parameter :: tolerance = 1.E-14_default
       d = fundamental_dimension (s)
       do i = 1, d
          allocate (rd (d), source = 0._default)
          rd(i) = 1
          call pol%init (s, rd)
          call pol%to_array (a)
          write (u, *)
          write (u, "(A,1X,I2)")  "h:", helicity_value (s, i)
          write (u, 1, advance="no")  a
          write (u, "(1X,L1)")  pol%is_diagonal ()
          write (u, 1)  pol%get_norm ()
          call pol%to_matrix (r)
          do j = 1, d
             rj = real (r(j,j))
             if (abs (rj) < tolerance)  rj = 0
             write (u, 1, advance="no")  rj
          end do
          write (u, "(1X,L1)")  matrix_is_diagonal (r)
          deallocate (a, rd, r)
       end do
 1     format (99(1X,F7.4,:))
     end subroutine bloch_diagonal
 
     function matrix_is_diagonal (r) result (diagonal)
       complex(default), dimension(:,:), intent(in) :: r
       logical :: diagonal
       integer :: i, j
       diagonal = .true.
       do j = 1, size (r, 2)
          do i = 1, size (r, 1)
             if (i == j)  cycle
             if (r(i,j) /= 0) then
                diagonal = .false.
                return
             end if
          end do
       end do
     end function matrix_is_diagonal
 
   end subroutine bloch_vectors_2
 
 @ %def bloch_vectors_2
 @
 \subsubsection{Pure state (arbitrary)}
 Initialize the Bloch vector with an arbitrarily chosen pure state,
 check the normalization, and transform back to the density matrix.
 <<Bloch vectors: execute tests>>=
   call test (bloch_vectors_3, "bloch_vectors_3", &
        "pure state (arbitrary)", &
        u, results)
 <<Bloch vectors: test declarations>>=
   public :: bloch_vectors_3
 <<Bloch vectors: tests>>=
   subroutine bloch_vectors_3 (u)
     integer, intent(in) :: u
 
     write (u, "(A)")  "* Test output: bloch_vectors_3"
     write (u, "(A)")  "*   Purpose: test Bloch-vector &
          &polarization implementation"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialization (pure polarized, arbitrary):"
     write (u, "(A)")  "*   input matrix, transform, display norm, transform back"
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 0"
     call bloch_arbitrary (SCALAR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1/2"
     call bloch_arbitrary (SPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1"
     call bloch_arbitrary (VECTOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 3/2"
     call bloch_arbitrary (VECTORSPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 2"
     call bloch_arbitrary (TENSOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: bloch_vectors_3"
 
   contains
 
     subroutine bloch_arbitrary (s)
       integer, intent(in) :: s
       type(bloch_vector_t) :: pol
       complex(default), dimension(:,:), allocatable :: r
       integer :: d
       d = fundamental_dimension (s)
       write (u, *)
       call init_matrix (d, r)
       call write_matrix (d, r)
       call pol%init (s, r)
       write (u, *)
       write (u, 2)  pol%get_norm (), pol%is_diagonal ()
       write (u, *)
       call pol%to_matrix (r)
       call write_matrix (d, r)
 2     format (1X,F7.4,1X,L1)
     end subroutine bloch_arbitrary
 
     subroutine init_matrix (d, r)
       integer, intent(in) :: d
       complex(default), dimension(:,:), allocatable, intent(out) :: r
       complex(default), dimension(:), allocatable :: a
       real(default) :: norm
       integer :: i, j
       allocate (a (d))
       norm = 0
       do i = 1, d
          a(i) = cmplx (2*i-1, 2*i, kind=default)
          norm = norm + conjg (a(i)) * a(i)
       end do
       a = a / sqrt (norm)
       allocate (r (d,d))
       do i = 1, d
          do j = 1, d
             r(i,j) = conjg (a(i)) * a(j)
          end do
       end do
     end subroutine init_matrix
 
     subroutine write_matrix (d, r)
       integer, intent(in) :: d
       complex(default), dimension(:,:), intent(in) :: r
       integer :: i, j
       do i = 1, d
          do j = 1, d
             write (u, 1, advance="no")  r(i,j)
          end do
          write (u, *)
       end do
 1     format (99(1X,'(',F7.4,',',F7.4,')',:))
     end subroutine write_matrix
 
   end subroutine bloch_vectors_3
 
 @ %def bloch_vectors_3
 @
 \subsubsection{Raw I/O}
 Check correct input/output in raw format.
 <<Bloch vectors: execute tests>>=
   call test (bloch_vectors_4, "bloch_vectors_4", &
        "raw I/O", &
        u, results)
 <<Bloch vectors: test declarations>>=
   public :: bloch_vectors_4
 <<Bloch vectors: tests>>=
   subroutine bloch_vectors_4 (u)
     integer, intent(in) :: u
 
     write (u, "(A)")  "* Test output: bloch_vectors_4"
     write (u, "(A)")  "*   Purpose: test Bloch-vector &
          &polarization implementation"
     write (u, "(A)")
 
     write (u, "(A)")  "* Raw I/O"
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 0"
     call bloch_io (SCALAR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1/2"
     call bloch_io (SPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1"
     call bloch_io (VECTOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 3/2"
     call bloch_io (VECTORSPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 2"
     call bloch_io (TENSOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: bloch_vectors_4"
 
   contains
 
     subroutine bloch_io (s)
       integer, intent(in) :: s
       type(bloch_vector_t) :: pol
       real(default), dimension(:), allocatable :: a
       integer :: n, i, utmp, iostat
       n = algebra_dimension (s)
       allocate (a (n))
       a(:) = [(real (mod (i, 10), kind=default), i = 1, size (a))]
       write (u, *)
       write (u, "(*(F7.4))")  a
       call pol%init (s)
       call pol%from_array (a)
       open (newunit = utmp, status = "scratch", action = "readwrite", &
            form = "unformatted")
       call pol%write_raw (utmp)
       rewind (utmp)
       call pol%read_raw (utmp, iostat=iostat)
       close (utmp)
       call pol%to_array (a)
       write (u, "(*(F7.4))")  a
     end subroutine bloch_io
 
   end subroutine bloch_vectors_4
 
 @ %def bloch_vectors_4
 @
 \subsubsection{Convenience Methods}
 Check some further TBP that are called by the [[polarizations]]
 module.
 <<Bloch vectors: execute tests>>=
   call test (bloch_vectors_5, "bloch_vectors_5", &
        "massless state (unpolarized)", &
        u, results)
 <<Bloch vectors: test declarations>>=
   public :: bloch_vectors_5
 <<Bloch vectors: tests>>=
   subroutine bloch_vectors_5 (u)
     integer, intent(in) :: u
 
     write (u, "(A)")  "* Test output: bloch_vectors_5"
     write (u, "(A)")  "*   Purpose: test Bloch-vector &
          &polarization implementation"
     write (u, "(A)")
 
     write (u, "(A)")  "* Massless states: equipartition"
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 0"
     call bloch_massless_unpol (SCALAR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1/2"
     call bloch_massless_unpol (SPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1"
     call bloch_massless_unpol (VECTOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 3/2"
     call bloch_massless_unpol (VECTORSPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 2"
     call bloch_massless_unpol (TENSOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: bloch_vectors_5"
 
   contains
 
     subroutine bloch_massless_unpol (s)
       integer, intent(in) :: s
       type(bloch_vector_t) :: pol
       complex(default), dimension(:,:), allocatable :: r
       real(default), dimension(:), allocatable :: a
       integer :: d
       d = fundamental_dimension (s)
       call pol%init_max_weight (s)
       call pol%to_matrix (r, only_max_weight = .false.)
       write (u, *)
       where (abs (r) < 1.e-14_default)  r = 0
       call write_matrix (d, r)
       call pol%to_matrix (r, only_max_weight = .true.)
       write (u, *)
       call write_matrix (d, r)
     end subroutine bloch_massless_unpol
 
     subroutine write_matrix (d, r)
       integer, intent(in) :: d
       complex(default), dimension(:,:), intent(in) :: r
       integer :: i, j
       do i = 1, d
          do j = 1, d
             write (u, 1, advance="no")  r(i,j)
          end do
          write (u, *)
       end do
 1     format (99(1X,'(',F7.4,',',F7.4,')',:))
     end subroutine write_matrix
 
   end subroutine bloch_vectors_5
 
 @ %def bloch_vectors_5
 @
 \subsubsection{Massless state (arbitrary)}
 Initialize the Bloch vector with an arbitrarily chosen pure state
 which consists only of highest-weight components.  Transform back to
 the density matrix.
 <<Bloch vectors: execute tests>>=
   call test (bloch_vectors_6, "bloch_vectors_6", &
        "massless state (arbitrary)", &
        u, results)
 <<Bloch vectors: test declarations>>=
   public :: bloch_vectors_6
 <<Bloch vectors: tests>>=
   subroutine bloch_vectors_6 (u)
     integer, intent(in) :: u
 
     write (u, "(A)")  "* Test output: bloch_vectors_6"
     write (u, "(A)")  "*   Purpose: test Bloch-vector &
          &polarization implementation"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialization (pure polarized massless, arbitrary):"
     write (u, "(A)")  "*   input matrix, transform, display norm, transform back"
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 0"
     call bloch_massless (SCALAR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1/2"
     call bloch_massless (SPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1"
     call bloch_massless (VECTOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 3/2"
     call bloch_massless (VECTORSPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 2"
     call bloch_massless (TENSOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: bloch_vectors_6"
 
   contains
 
     subroutine bloch_massless (s)
       integer, intent(in) :: s
       type(bloch_vector_t) :: pol
       complex(default), dimension(:,:), allocatable :: r
       integer :: d
       d = fundamental_dimension (s)
       write (u, *)
       call init_matrix (d, r)
       call write_matrix (d, r)
       call pol%init (s, r)
       write (u, *)
       write (u, 2)  pol%get_norm (), pol%is_diagonal ()
       write (u, *)
       call pol%to_matrix (r, only_max_weight = .true.)
       call write_matrix (d, r)
 2     format (1X,F7.4,1X,L1)
     end subroutine bloch_massless
 
     subroutine init_matrix (d, r)
       integer, intent(in) :: d
       complex(default), dimension(:,:), allocatable, intent(out) :: r
       complex(default), dimension(:), allocatable :: a
       real(default) :: norm
       integer :: i, j
       allocate (a (d), source = (0._default, 0._default))
       norm = 0
       do i = 1, d, max (d-1, 1)
          a(i) = cmplx (2*i-1, 2*i, kind=default)
          norm = norm + conjg (a(i)) * a(i)
       end do
       a = a / sqrt (norm)
       allocate (r (d,d), source = (0._default, 0._default))
       do i = 1, d, max (d-1, 1)
          do j = 1, d, max (d-1, 1)
             r(i,j) = conjg (a(i)) * a(j)
          end do
       end do
     end subroutine init_matrix
 
     subroutine write_matrix (d, r)
       integer, intent(in) :: d
       complex(default), dimension(:,:), intent(in) :: r
       integer :: i, j
       do i = 1, d
          do j = 1, d
             write (u, 1, advance="no")  r(i,j)
          end do
          write (u, *)
       end do
 1     format (99(1X,'(',F7.4,',',F7.4,')',:))
     end subroutine write_matrix
 
   end subroutine bloch_vectors_6
 
 @ %def bloch_vectors_6
 @
 \subsubsection{Massless state (Bloch vector)}
 Initialize the (generalized) Bloch vector with an ordinary
 three-component Bloch vector that applies to the highest-weight part only.
 <<Bloch vectors: execute tests>>=
   call test (bloch_vectors_7, "bloch_vectors_7", &
        "massless state (vector)", &
        u, results)
 <<Bloch vectors: test declarations>>=
   public :: bloch_vectors_7
 <<Bloch vectors: tests>>=
   subroutine bloch_vectors_7 (u)
     integer, intent(in) :: u
 
     write (u, "(A)")  "* Test output: bloch_vectors_7"
     write (u, "(A)")  "*   Purpose: test Bloch-vector &
          &polarization implementation"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialization &
          &(pure polarized massless, arbitrary Bloch vector):"
     write (u, "(A)")  "*   input vector, transform, display norm, &
          &transform back"
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 0"
     call bloch_massless_vector (SCALAR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1/2"
     call bloch_massless_vector (SPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 1"
     call bloch_massless_vector (VECTOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 3/2"
     call bloch_massless_vector (VECTORSPINOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* s = 2"
     call bloch_massless_vector (TENSOR)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: bloch_vectors_7"
 
   contains
 
     subroutine bloch_massless_vector (s)
       integer, intent(in) :: s
       type(bloch_vector_t) :: pol
       real(default), dimension(3) :: a
       complex(default), dimension(:,:), allocatable :: r
       write (u, *)
       a =  [1._default, 2._default, 4._default]
       a = a / sqrt (sum (a ** 2))
       write (u, 2)  a
       call pol%init_vector (s, a)
       write (u, 2)  pol%get_norm ()
       call pol%to_vector (a)
       write (u, 2)  a
       call pol%to_matrix (r, only_max_weight = .false.)
       write (u, *)
       where (abs (r) < 1.e-14_default)  r = 0
       call write_matrix (r)
       call pol%to_matrix (r, only_max_weight = .true.)
       write (u, *)
       call write_matrix (r)
 2     format (99(1X,F7.4,:))
     end subroutine bloch_massless_vector
 
     subroutine write_matrix (r)
       complex(default), dimension(:,:), intent(in) :: r
       integer :: i, j
       do i = 1, size (r, 1)
          do j = 1, size (r, 2)
             write (u, 1, advance="no")  r(i,j)
          end do
          write (u, *)
       end do
 1     format (99(1X,'(',F7.4,',',F7.4,')',:))
     end subroutine write_matrix
 
   end subroutine bloch_vectors_7
 
 @ %def bloch_vectors_7
 @
 \clearpage
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Polarization}
 Using generalized Bloch vectors and the $su(N)$ algebra (see above)
 for the internal representation, we can define various modes of
 polarization.  For
 spin-1/2, and analogously for massless spin-$s$ particles, we introduce
 \begin{enumerate}
 \item Trivial polarization: $\vec\alpha=0$. [This is unpolarized, but
   distinct from the particular undefined polarization matrix which has
   the same meaning.]
 \item Circular polarization: $\vec\alpha$ points in $\pm z$ direction.
 \item Transversal polarization: $\vec\alpha$ points orthogonal to the
   $z$ direction, with a phase $\phi$ that is $0$ for the $x$ axis, and
   $\pi/2=90^\circ$ for the $y$ axis.  For antiparticles, the phase
   switches sign, corresponding to complex conjugation.
 \item Axis polarization, where we explicitly give $\vec\alpha$.
 \end{enumerate}
 For higher spin, we retain this definition, but apply it to the two
 components with maximum and minimum weight.  In effect, we concentrate
 on the first three entries in the $\alpha^a$ array.  For massless
 particles, this is sufficient.  For massive particles, we then add the
 possibilities:
 \begin{enumerate}\setcounter{enumi}{4}
 \item Longitudinal polarization: Only the 0-component is set.  This is
   possible only for bosons.
 \item Diagonal polarization: Explicitly specify all components in the
   helicity basis.  The $su(N)$ representation consists of diagonal
   generators only, the Cartan subalgebra.
 \end{enumerate}
 Obviously, this does not exhaust the possible density matrices for
 higher spin, but it should cover practical applications.
 <<[[polarizations.f90]]>>=
 <<File header>>
 
 module polarizations
 
 <<Use kinds>>
   use io_units
   use format_defs, only: FMT_19
   use diagnostics
   use physics_defs, only: SCALAR, SPINOR, VECTOR, VECTORSPINOR, TENSOR
   use flavors
   use helicities
   use quantum_numbers
   use state_matrices
   use bloch_vectors
 
 <<Standard module head>>
 
 <<Polarizations: public>>
 
 <<Polarizations: types>>
 
 <<Polarizations: interfaces>>
 
 contains
 
 <<Polarizations: procedures>>
 
 end module polarizations
 @ %def polarizations
 @
 \subsection{The polarization type}
 Polarization is active whenever the coefficient array is allocated.
 For convenience, we store the spin type ($2s$) and the multiplicity
 ($N$) together with the coefficient array ($\alpha$).  We have to allow for
 the massless case where $s$ is arbitrary $>0$ but $N=2$, and
 furthermore the chiral massless case where $N=1$.  In the latter case,
 the array remains deallocated but the chirality is set to $\pm 1$.
 
 There is a convention that an antiparticle transforms according to the
 complex conjugate representation.  We apply this only when
 transforming from/to polarization defined by a three-vector.  For
 antiparticles, the two-component flips sign in that case.  When
 transforming from/to a state matrix or [[pmatrix]] representation, we
 do not apply this sign flip.
 
 TODO: Check these conventions for consistency.
 <<Polarizations: public>>=
   public :: polarization_t
 <<Polarizations: types>>=
   type :: polarization_t
      private
      integer :: spin_type = SCALAR
      integer :: multiplicity = 1
      integer :: chirality = 0
      logical :: anti = .false.
      type(bloch_vector_t) :: bv
    contains
    <<Polarizations: polarization: TBP>>
   end type polarization_t
 
 @ %def polarization_t
 @
 \subsection{Basic initializer and finalizer}
 We need the particle flavor for determining the allowed helicity
 values.  The Bloch vector is left undefined, so this initializer (in
 two versions) creates an unpolarized particle.  Exception: a chiral
 particle is always polarized with definite helicity, it doesn't need a
 Bloch vector.
 
 This is private.
 <<Polarizations: polarization: TBP>>=
   generic, private :: init => polarization_init, polarization_init_flv
   procedure, private :: polarization_init
   procedure, private :: polarization_init_flv
 <<Polarizations: procedures>>=
   subroutine polarization_init (pol, spin_type, multiplicity, &
        anti, left_handed, right_handed)
     class(polarization_t), intent(out) :: pol
     integer, intent(in) :: spin_type
     integer, intent(in) :: multiplicity
     logical, intent(in) :: anti
     logical, intent(in) :: left_handed
     logical, intent(in) :: right_handed
     pol%spin_type = spin_type
     pol%multiplicity = multiplicity
     pol%anti = anti
     select case (pol%multiplicity)
     case (1)
        if (left_handed) then
           pol%chirality = -1
        else if (right_handed) then
           pol%chirality = 1
        end if
     end select
     select case (pol%chirality)
     case (0)
        call pol%bv%init_unpolarized (spin_type)
     end select
   end subroutine polarization_init
 
   subroutine polarization_init_flv (pol, flv)
     class(polarization_t), intent(out) :: pol
     type(flavor_t), intent(in) :: flv
     call pol%init ( &
          spin_type = flv%get_spin_type (), &
          multiplicity = flv%get_multiplicity (), &
          anti = flv%is_antiparticle (), &
          left_handed = flv%is_left_handed (), &
          right_handed = flv%is_right_handed ())
   end subroutine polarization_init_flv
 
 @ %def polarization_init polarization_init_flv
 @ Generic polarization: as before, but create a polarized particle
 (Bloch vector defined) with initial polarization zero.
 <<Polarizations: polarization: TBP>>=
   generic :: init_generic => &
        polarization_init_generic, &
        polarization_init_generic_flv
   procedure, private :: polarization_init_generic
   procedure, private :: polarization_init_generic_flv
 <<Polarizations: procedures>>=
   subroutine polarization_init_generic (pol, spin_type, multiplicity, &
        anti, left_handed, right_handed)
     class(polarization_t), intent(out) :: pol
     integer, intent(in) :: spin_type
     integer, intent(in) :: multiplicity
     logical, intent(in) :: anti
     logical, intent(in) :: left_handed
     logical, intent(in) :: right_handed
     call pol%init (spin_type, multiplicity, &
          anti, left_handed, right_handed)
     select case (pol%chirality)
     case (0)
        if (pol%multiplicity == pol%bv%get_n_states ()) then
           call pol%bv%init (spin_type)
        else
           call pol%bv%init_max_weight (spin_type)
        end if
     end select
   end subroutine polarization_init_generic
 
   subroutine polarization_init_generic_flv (pol, flv)
     class(polarization_t), intent(out) :: pol
     type(flavor_t), intent(in) :: flv
     call pol%init_generic ( &
          spin_type = flv%get_spin_type (), &
          multiplicity = flv%get_multiplicity (), &
          anti = flv%is_antiparticle (), &
          left_handed = flv%is_left_handed (), &
          right_handed = flv%is_right_handed ())
   end subroutine polarization_init_generic_flv
 
 @ %def polarization_init_generic
 @ A finalizer is no longer necessary.
 
 \subsection{I/O}
 The default setting produces a tabular output of the polarization
 vector entries.  Optionally, we can create a state matrix and write
 its contents, emulating the obsolete original implementation.
 
 If [[all_states]] is true (default), we generate all helity
 combinations regardless of the matrix-element value.  Otherwise, skip
 helicities with zero entry, or absolute value less than [[tolerance]],
 if also given.
 <<Polarizations: polarization: TBP>>=
   procedure :: write => polarization_write
 <<Polarizations: procedures>>=
   subroutine polarization_write (pol, unit, state_matrix, all_states, tolerance)
     class(polarization_t), intent(in) :: pol
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: state_matrix, all_states
     real(default), intent(in), optional :: tolerance
     logical :: state_m
     type(state_matrix_t) :: state
     real(default), dimension(:), allocatable :: a
     integer :: u, i
     u = given_output_unit (unit);  if (u < 0)  return
     state_m = .false.;  if (present (state_matrix))  state_m = state_matrix
     if (pol%anti) then
        write (u, "(1x,A,I1,A,I1,A,L1,A)")  &
             "Polarization: [spin_type = ", pol%spin_type, &
             ", mult = ", pol%multiplicity, ", anti = ", pol%anti, "]"
     else
        write (u, "(1x,A,I1,A,I1,A)")  &
             "Polarization: [spin_type = ", pol%spin_type, &
             ", mult = ", pol%multiplicity, "]"
     end if
     if (state_m) then
        call pol%to_state (state, all_states, tolerance)
        call state%write (unit=unit)
        call state%final ()
     else if (pol%chirality == 1) then
        write (u, "(1x,A)")  "chirality = +"
     else if (pol%chirality == -1) then
        write (u, "(1x,A)")  "chirality = -"
     else if (pol%bv%is_polarized ()) then
        call pol%bv%to_array (a)
        do i = 1, size (a)
           write (u, "(1x,I2,':',1x,F10.7)")  i, a(i)
        end do
     else
        write (u, "(1x,A)")  "[unpolarized]"
     end if
   end subroutine polarization_write
 
 @ %def polarization_write
 @ Binary I/O.
 <<Polarizations: polarization: TBP>>=
   procedure :: write_raw => polarization_write_raw
   procedure :: read_raw => polarization_read_raw
 <<Polarizations: procedures>>=
   subroutine polarization_write_raw (pol, u)
     class(polarization_t), intent(in) :: pol
     integer, intent(in) :: u
     write (u) pol%spin_type
     write (u) pol%multiplicity
     write (u) pol%chirality
     write (u) pol%anti
     call pol%bv%write_raw (u)
   end subroutine polarization_write_raw
 
   subroutine polarization_read_raw (pol, u, iostat)
     class(polarization_t), intent(out) :: pol
     integer, intent(in) :: u
     integer, intent(out), optional :: iostat
     read (u, iostat=iostat) pol%spin_type
     read (u, iostat=iostat) pol%multiplicity
     read (u, iostat=iostat) pol%chirality
     read (u, iostat=iostat) pol%anti
     call pol%bv%read_raw (u, iostat)
   end subroutine polarization_read_raw
 
 @ %def polarization_read_raw
 @
 \subsection{Accessing contents}
 Return true if the particle is technically polarized.  The particle
 is either chiral, or its Bloch vector has been defined.  The
 function returns true even if the Bloch vector is zero or the particle
 is scalar.
 <<Polarizations: polarization: TBP>>=
   procedure :: is_polarized => polarization_is_polarized
 <<Polarizations: procedures>>=
   function polarization_is_polarized (pol) result (polarized)
     class(polarization_t), intent(in) :: pol
     logical :: polarized
     polarized = pol%chirality /= 0 .or. pol%bv%is_polarized ()
   end function polarization_is_polarized
 
 @ %def polarization_is_polarized
 @ Return true if the polarization is diagonal, i.e., all entries in
 the density matrix are diagonal.  For an unpolarized particle, we also
 return [[.true.]] since the density matrix is proportional to the unit
 matrix.
 <<Polarizations: polarization: TBP>>=
   procedure :: is_diagonal => polarization_is_diagonal
 <<Polarizations: procedures>>=
   function polarization_is_diagonal (pol) result (diagonal)
     class(polarization_t), intent(in) :: pol
     logical :: diagonal
     select case (pol%chirality)
     case (0)
        diagonal = pol%bv%is_diagonal ()
     case default
        diagonal = .true.
     end select
   end function polarization_is_diagonal
 
 @ %def polarization_is_diagonal
 @
 \subsection{Mapping between polarization and state matrix}
 Create the polarization object that corresponds to a state matrix.  The state
 matrix is not necessarily normalized.  The result will be either unpolarized,
 or a generalized Bloch vector that we compute in terms of the appropriate spin
 generator basis.  To this end, we first construct the complete density
 matrix, then set the Bloch vector with this input.
 
 For a naturally chiral particle (i.e., neutrino), we do not set the
 polarization vector, it is implied.
 
 TODO: The state matrix does not support an antiparticle flag.
 Therefore, we cannot account for any sign flip and transform as-is.
 <<Polarizations: polarization: TBP>>=
   procedure :: init_state_matrix => polarization_init_state_matrix
 <<Polarizations: procedures>>=
   subroutine polarization_init_state_matrix (pol, state)
     class(polarization_t), intent(out) :: pol
     type(state_matrix_t), intent(in), target :: state
     type(state_iterator_t) :: it
     type(flavor_t) :: flv
     type(helicity_t) :: hel
     integer :: d, h1, h2, i, j
     complex(default), dimension(:,:), allocatable :: r
     complex(default) :: me
     real(default) :: trace
     call it%init (state)
     flv = it%get_flavor (1)
     hel = it%get_helicity (1)
     if (hel%is_defined ()) then
        call pol%init_generic (flv)
        select case (pol%chirality)
        case (0)
           trace = 0
           d = pol%bv%get_n_states ()
           allocate (r (d, d), source = (0._default, 0._default))
           do while (it%is_valid ())
              hel = it%get_helicity (1)
              call hel%get_indices (h1, h2)
              i = pol%bv%hel_index (h1)
              j = pol%bv%hel_index (h2)
              me = it%get_matrix_element ()
              r(i,j) = me
              if (i == j)  trace = trace + real (me)
              call it%advance ()
           end do
           if (trace /= 0)  call pol%bv%set (r / trace)
        end select
     else
        call pol%init (flv)
     end if
   end subroutine polarization_init_state_matrix
 
 @ %def polarization_init_state_matrix
 @ Create the state matrix that corresponds to a given polarization.  We make
 use of the polarization iterator as defined below, which should iterate
 according to the canonical helicity ordering.
 <<Polarizations: polarization: TBP>>=
   procedure :: to_state => polarization_to_state_matrix
 <<Polarizations: procedures>>=
   subroutine polarization_to_state_matrix (pol, state, all_states, tolerance)
     class(polarization_t), intent(in), target :: pol
     type(state_matrix_t), intent(out) :: state
     logical, intent(in), optional :: all_states
     real(default), intent(in), optional :: tolerance
     type(polarization_iterator_t) :: it
     type(quantum_numbers_t), dimension(1) :: qn
     complex(default) :: value
     call it%init (pol, all_states, tolerance)
     call state%init (store_values = .true.)
     do while (it%is_valid ())
        value = it%get_value ()
        qn(1) = it%get_quantum_numbers ()
        call state%add_state (qn, value = value)
        call it%advance ()
     end do
     call state%freeze ()
   end subroutine polarization_to_state_matrix
 
 @ %def polarization_to_state_matrix
 @
 \subsection{Specific initializers}
 Unpolarized particle, no nontrivial entries in the density matrix.  This
 is the default initialization mode.
 <<Polarizations: polarization: TBP>>=
   procedure :: init_unpolarized => polarization_init_unpolarized
 <<Polarizations: procedures>>=
   subroutine polarization_init_unpolarized (pol, flv)
     class(polarization_t), intent(out) :: pol
     type(flavor_t), intent(in) :: flv
     call pol%init (flv)
   end subroutine polarization_init_unpolarized
 
 @ %def polarization_init_unpolarized
 @ The following three modes are useful mainly for spin-1/2 particle
 and massless particles of any nonzero spin.  Only the highest-weight
 components are filled.
 
 Circular polarization: The density matrix of the two highest-weight
 states is
 \begin{equation*}
   \rho(f) =
   \frac{1-|f|}{2}\mathbf{1} +
   |f| \times
   \begin{cases}
     \begin{pmatrix} 1 & 0 \\ 0 & 0 \end{pmatrix}, & f > 0; \\[6pt]
     \begin{pmatrix} 0 & 0 \\ 0 & 1 \end{pmatrix}, & f < 0,
   \end{cases}
 \end{equation*}
 In the generalized Bloch representation, this is an entry for the $T^3$
 generator only, regardless of the spin representation.
 
 A chiral particle is not affected.
 <<Polarizations: polarization: TBP>>=
   procedure :: init_circular => polarization_init_circular
 <<Polarizations: procedures>>=
   subroutine polarization_init_circular (pol, flv, f)
     class(polarization_t), intent(out) :: pol
     type(flavor_t), intent(in) :: flv
     real(default), intent(in) :: f
     call pol%init (flv)
     select case (pol%chirality)
     case (0)
        call pol%bv%init_vector (pol%spin_type, &
             [0._default, 0._default, f])
     end select
   end subroutine polarization_init_circular
 
 @ %def polarization_init_circular
 @ Transversal polarization is analogous to circular, but we get a
 density matrix
 \begin{equation*}
   \rho(f,\phi) =
   \frac{1-|f|}{2}\mathbf{1}
   + \frac{|f|}{2}  \begin{pmatrix} 1 & e^{-i\phi} \\ e^{i\phi} & 1
   \end{pmatrix}.
 \end{equation*}
 for the highest-weight subspace.  The lower weights are unaffected.
 The phase is $\phi=0$ for the $x$-axis, $\phi=90^\circ$ for the $y$
 axis as polarization vector.
 
 For an antiparticle, the phase switches sign, and for $f<0$, the
 off-diagonal elements switch sign.
 
 A chiral particle is not affected.
 <<Polarizations: polarization: TBP>>=
   procedure :: init_transversal => polarization_init_transversal
 <<Polarizations: procedures>>=
   subroutine polarization_init_transversal (pol, flv, phi, f)
     class(polarization_t), intent(out) :: pol
     type(flavor_t), intent(in) :: flv
     real(default), intent(in) :: phi, f
     call pol%init (flv)
     select case (pol%chirality)
     case (0)
        if (pol%anti) then
           call pol%bv%init_vector (pol%spin_type, &
                [f * cos (phi), f * sin (phi), 0._default])
        else
           call pol%bv%init_vector (pol%spin_type, &
                [f * cos (phi),-f * sin (phi), 0._default])
        end if
     end select
   end subroutine polarization_init_transversal
 
 @ %def polarization_init_transversal
 @ For axis polarization, we again set only the entries with maximum weight,
 which for spin $1/2$ means
 \begin{equation*}
   \rho(f,\phi) =
   \frac{1}{2} \begin{pmatrix}
                  1 + \alpha_3 & \alpha_1 - i\alpha_2 \\
                  \alpha_1 + i\alpha_2 & 1 - \alpha_3
               \end{pmatrix}.
 \end{equation*}
 For an antiparticle, the imaginary part proportional to $\alpha_2$ switches
 sign (complex conjugate).  A chiral particle is not affected.
 
 In the generalized Bloch representation, this translates into coefficients for
 $T^{1,2,3}$, all others stay zero.
 <<Polarizations: polarization: TBP>>=
   procedure :: init_axis => polarization_init_axis
 <<Polarizations: procedures>>=
   subroutine polarization_init_axis (pol, flv, alpha)
     class(polarization_t), intent(out) :: pol
     type(flavor_t), intent(in) :: flv
     real(default), dimension(3), intent(in) :: alpha
     call pol%init (flv)
     select case (pol%chirality)
     case (0)
        if (pol%anti) then
           call pol%bv%init_vector (pol%spin_type, &
                [alpha(1), alpha(2), alpha(3)])
        else
           call pol%bv%init_vector (pol%spin_type, &
                [alpha(1),-alpha(2), alpha(3)])
        end if
     end select
   end subroutine polarization_init_axis
 
 @ %def polarization_init_axis
 @ This version specifies the polarization axis in terms of $r$
 (polarization degree) and $\theta,\phi$ (polar and azimuthal angles).
 
 If one of the angles is a nonzero multiple of $\pi$, roundoff errors
 typically will result in tiny contributions to unwanted components.
 Therefore, include a catch for small numbers.
 <<Polarizations: polarization: TBP>>=
   procedure :: init_angles => polarization_init_angles
 <<Polarizations: procedures>>=
   subroutine polarization_init_angles (pol, flv, r, theta, phi)
     class(polarization_t), intent(out) :: pol
     type(flavor_t), intent(in) :: flv
     real(default), intent(in) :: r, theta, phi
     real(default), dimension(3) :: alpha
     real(default), parameter :: eps = 10 * epsilon (1._default)
 
     alpha(1) = r * sin (theta) * cos (phi)
     alpha(2) = r * sin (theta) * sin (phi)
     alpha(3) = r * cos (theta)
     where (abs (alpha) < eps)  alpha = 0
     call pol%init_axis (flv, alpha)
   end subroutine polarization_init_angles
 
 @ %def polarization_init_angles
 @ Longitudinal polarization is defined only for massive bosons.  Only
 the zero component is filled.  Otherwise, unpolarized.
 
 In the generalized Bloch representation, the zero component corresponds to a
 linear combination of all diagonal (Cartan) generators.
 <<Polarizations: polarization: TBP>>=
   procedure :: init_longitudinal => polarization_init_longitudinal
 <<Polarizations: procedures>>=
   subroutine polarization_init_longitudinal (pol, flv, f)
     class(polarization_t), intent(out) :: pol
     type(flavor_t), intent(in) :: flv
     real(default), intent(in) :: f
     real(default), dimension(:), allocatable :: rd
     integer :: s, d
     s = flv%get_spin_type ()
     select case (s)
     case (VECTOR, TENSOR)
        call pol%init_generic (flv)
        if (pol%bv%is_polarized ()) then
           d = pol%bv%get_n_states ()
           allocate (rd (d), source = 0._default)
           rd(pol%bv%hel_index (0)) = f
           call pol%bv%set (rd)
        end if
     case default
        call pol%init_unpolarized (flv)
     end select
   end subroutine polarization_init_longitudinal
 
 @ %def polarization_init_longitudinal
 @ This is diagonal polarization: we specify all components explicitly.
 [[rd]] is the array of diagonal elements of the density matrix.  We
 assume that the length of [[rd]] is equal to the particle
 multiplicity.
 <<Polarizations: polarization: TBP>>=
   procedure :: init_diagonal => polarization_init_diagonal
 <<Polarizations: procedures>>=
   subroutine polarization_init_diagonal (pol, flv, rd)
     class(polarization_t), intent(out) :: pol
     type(flavor_t), intent(in) :: flv
     real(default), dimension(:), intent(in) :: rd
     real(default) :: trace
     call pol%init_generic (flv)
     if (pol%bv%is_polarized ()) then
        trace = sum (rd)
        if (trace /= 0)  call pol%bv%set (rd / trace)
     end if
   end subroutine polarization_init_diagonal
 
 @ %def polarization_init_diagonal
 @
 \subsection{Operations}
 Combine polarization states by computing the outer product of the
 state matrices.
 <<Polarizations: public>>=
   public :: combine_polarization_states
 <<Polarizations: procedures>>=
   subroutine combine_polarization_states (pol, state)
     type(polarization_t), dimension(:), intent(in), target :: pol
     type(state_matrix_t), intent(out) :: state
     type(state_matrix_t), dimension(size(pol)), target :: pol_state
     integer :: i
     do i = 1, size (pol)
        call pol(i)%to_state (pol_state(i))
     end do
     call outer_multiply (pol_state, state)
     do i = 1, size (pol)
        call pol_state(i)%final ()
     end do
   end subroutine combine_polarization_states
 
 @ %def combine_polarization_states
 @ Transform a polarization density matrix into a polarization vector.  This is
 possible without information loss only for spin-1/2 and for massless
 particles.  To get a unique answer in all cases, we consider only the
 components with highest weight.  Obviously, this loses the longitudinal
 component of a massive vector, for instance.  The norm of the returned axis is
 the polarization fraction for the highest-weight subspace.  For a scalar
 particle, we return a zero vector.  The same result applies if the
 highest-weight component vanishes.
 
 This is the inverse operation of [[polarization_init_axis]] above,
 where the polarization fraction is set to unity.
 
 For an antiparticle, the [[alpha(2)]] coefficient flips sign.
 <<Polarizations: polarization: TBP>>=
   procedure :: get_axis => polarization_get_axis
 <<Polarizations: procedures>>=
   function polarization_get_axis (pol) result (alpha)
     class(polarization_t), intent(in), target :: pol
     real(default), dimension(3) :: alpha
     select case (pol%chirality)
     case (0)
        call pol%bv%to_vector (alpha)
        if (.not. pol%anti)  alpha(2) = - alpha(2)
     case (-1)
        alpha = [0._default, 0._default, -1._default]
     case (1)
        alpha = [0._default, 0._default, 1._default]
     end select
   end function polarization_get_axis
 
 @ %def polarization_get_axis
 @ This function returns polarization degree and polar and azimuthal
 angles ($\theta,\phi$) of the polarization axis.  The same restrictions apply
 as above.
 
 Since we call the [[get_axis]] method, the phase flips sign for an
 antiparticle.
 <<Polarizations: polarization: TBP>>=
   procedure :: to_angles => polarization_to_angles
 <<Polarizations: procedures>>=
   subroutine polarization_to_angles (pol, r, theta, phi)
     class(polarization_t), intent(in) :: pol
     real(default), intent(out) :: r, theta, phi
     real(default), dimension(3) :: alpha
     real(default) :: norm, r12
     alpha = pol%get_axis ()
     norm = sum (alpha**2)
     r = sqrt (norm)
     if (norm > 0) then
        r12 = sqrt (alpha(1)**2 + alpha(2)**2)
        theta = atan2 (r12, alpha(3))
        if (any (alpha(1:2) /= 0)) then
           phi = atan2 (alpha(2), alpha(1))
        else
           phi = 0
        end if
     else
        theta = 0
        phi = 0
     end if
   end subroutine polarization_to_angles
 
 @ %def polarization_to_angles
 @
 \subsection{Polarization Iterator}
 The iterator acts like a state matrix iterator, i.e., it points to one
 helicity combination at a time and can return the corresponding helicity
 object and matrix-element value.
 
 Since the polarization is stored as a Bloch vector, we recover the
 whole density matrix explicitly upon initialization, store it inside
 the iterator object, and then just return its elements one at a time.
 
 For an unpolarized particle, the iterator returns a single state with
 undefined helicity.  The value is the value of any diagonal density
 matrix element, $1/n$ where $n$ is the multiplicity.
 <<Polarizations: public>>=
   public :: polarization_iterator_t
 <<Polarizations: types>>=
   type :: polarization_iterator_t
      private
      type(polarization_t), pointer :: pol => null ()
      logical :: polarized = .false.
      integer :: h1 = 0
      integer :: h2 = 0
      integer :: i = 0
      integer :: j = 0
      complex(default), dimension(:,:), allocatable :: r
      complex(default) :: value = 1._default
      real(default) :: tolerance = -1._default
      logical :: valid = .false.
    contains
    <<Polarizations: polarization iterator: TBP>>
   end type polarization_iterator_t
 
 @ %def polarization_iterator_t
 @ Output for debugging purposes only, therefore no format for real/complex.
 <<Polarizations: polarization iterator: TBP>>=
   procedure :: write => polarization_iterator_write
 <<Polarizations: procedures>>=
   subroutine polarization_iterator_write (it, unit)
     class(polarization_iterator_t), intent(in) :: it
     integer, intent(in), optional :: unit
     integer :: u, i
     u = given_output_unit (unit)
     write (u, "(1X,A)")  "Polarization iterator:"
     write (u, "(3X,A,L1)")  "assigned = ", associated (it%pol)
     write (u, "(3X,A,L1)")  "valid    = ", it%valid
     if (it%valid) then
        write (u, "(3X,A,2(1X,I2))")  "i, j     = ", it%i, it%j
        write (u, "(3X,A,2(1X,I2))")  "h1, h2   = ", it%h1, it%h2
        write (u, "(3X,A)", advance="no")  "value    = "
        write (u, *)  it%value
        if (allocated (it%r)) then
           do i = 1, size (it%r, 2)
              write (u, *)  it%r(i,:)
           end do
        end if
     end if
   end subroutine polarization_iterator_write
 
 @ %def polarization_iterator_write
 @ Initialize, i.e., (virtually) point to the first helicity state
 supported by the polarization object.  If the density matrix is
 nontrivial, we calculate it here.
 
 Following the older state-matrix
 conventions, the iterator sequence starts at the lowest helicity
 value.  In the current internal representation, this corresponds to
 the highest index value.
 
 If the current matrix-element value is zero, advance the iterator.
 Advancing will stop at a nonzero value or if the iterator becomes
 invalid.
 
 If [[tolerance]] is given, any state matrix entry less or equal will
 be treated as zero, causing the iterator to skip an entry.  By
 default, the value is negative, so no entry is skipped.
 <<Polarizations: polarization iterator: TBP>>=
   procedure :: init => polarization_iterator_init
 <<Polarizations: procedures>>=
   subroutine polarization_iterator_init (it, pol, all_states, tolerance)
     class(polarization_iterator_t), intent(out) :: it
     type(polarization_t), intent(in), target :: pol
     logical, intent(in), optional :: all_states
     real(default), intent(in), optional :: tolerance
     integer :: d
     logical :: only_max_weight
     it%pol => pol
     if (present (all_states)) then
        if (.not. all_states) then
           if (present (tolerance)) then
              it%tolerance = tolerance
           else
              it%tolerance = 0
           end if
        end if
     end if
     select case (pol%chirality)
     case (0)
        d = pol%bv%get_n_states ()
        only_max_weight = pol%multiplicity < d
        it%polarized = pol%bv%is_polarized ()
        if (it%polarized) then
           it%i = d
           it%j = it%i
           it%h1 = pol%bv%hel_value (it%i)
           it%h2 = it%h1
           call pol%bv%to_matrix (it%r, only_max_weight)
           it%value = it%r(it%i, it%j)
        else
           it%value = 1._default / d
        end if
        it%valid = .true.
     case (1,-1)
        it%polarized = .true.
        select case (pol%spin_type)
        case (SPINOR)
           it%h1 = pol%chirality
        case (VECTORSPINOR)
           it%h1 = 2 * pol%chirality
        end select
        it%h2 = it%h1
        it%valid = .true.
     end select
     if (it%valid .and. abs (it%value) <= it%tolerance)  call it%advance ()
   end subroutine polarization_iterator_init
 
 @ %def polarization_iterator_init
 @ Advance to the next valid helicity state.  Repeat if the returned value is
 zero.
 
 For an unpolarized object, we iterate through the diagonal helicity
 states with a constant value.
 <<Polarizations: polarization iterator: TBP>>=
   procedure :: advance => polarization_iterator_advance
 <<Polarizations: procedures>>=
   recursive subroutine polarization_iterator_advance (it)
     class(polarization_iterator_t), intent(inout) :: it
     if (it%valid) then
        select case (it%pol%chirality)
        case (0)
           if (it%polarized) then
              if (it%j > 1) then
                 it%j = it%j - 1
                 it%h2 = it%pol%bv%hel_value (it%j)
                 it%value = it%r(it%i, it%j)
              else if (it%i > 1) then
                 it%j = it%pol%bv%get_n_states ()
                 it%h2 = it%pol%bv%hel_value (it%j)
                 it%i = it%i - 1
                 it%h1 = it%pol%bv%hel_value (it%i)
                 it%value = it%r(it%i, it%j)
              else
                 it%valid = .false.
              end if
           else
              it%valid = .false.
           end if
        case default
           it%valid = .false.
        end select
        if (it%valid .and. abs (it%value) <= it%tolerance)  call it%advance ()
     end if
   end subroutine polarization_iterator_advance
 
 @ %def polarization_iterator_advance
 @ This is true as long as the iterator points to a valid helicity state.
 <<Polarizations: polarization iterator: TBP>>=
   procedure :: is_valid => polarization_iterator_is_valid
 <<Polarizations: procedures>>=
   function polarization_iterator_is_valid (it) result (is_valid)
     logical :: is_valid
     class(polarization_iterator_t), intent(in) :: it
     is_valid = it%valid
   end function polarization_iterator_is_valid
 
 @ %def polarization_iterator_is_valid
 @ Return the matrix element value for the helicity that we are currently
 pointing at.
 <<Polarizations: polarization iterator: TBP>>=
   procedure :: get_value => polarization_iterator_get_value
 <<Polarizations: procedures>>=
   function polarization_iterator_get_value (it) result (value)
     complex(default) :: value
     class(polarization_iterator_t), intent(in) :: it
     if (it%valid) then
        value = it%value
     else
        value = 0
     end if
   end function polarization_iterator_get_value
 
 @ %def polarization_iterator_get_value
 @ Return a quantum number object for the helicity that we are currently
 pointing at.  This is a single quantum number object, not an array.
 
 Note that the [[init]] method of the helicity object has the order reversed.
 <<Polarizations: polarization iterator: TBP>>=
   procedure :: get_quantum_numbers => polarization_iterator_get_quantum_numbers
 <<Polarizations: procedures>>=
   function polarization_iterator_get_quantum_numbers (it) result (qn)
     class(polarization_iterator_t), intent(in) :: it
     type(helicity_t) :: hel
     type(quantum_numbers_t) :: qn
     if (it%polarized) then
        call hel%init (it%h2, it%h1)
     end if
     call qn%init (hel)
   end function polarization_iterator_get_quantum_numbers
 
 @ %def polarization_iterator_get_quantum_numbers
 @
 \subsection{Sparse Matrix}
 We introduce a simple implementation of a sparse matrix that can represent
 polarization (or similar concepts) for transfer to I/O within the
 program.  It consists of an integer array that represents the index
 values, and a complex array that represents the nonvanishing entries.  The
 number of nonvanishing entries must be known for initialization, but the
 entries are filled one at a time.
 
 Here is a base type without the special properties of a spin-density matrix.
 <<Polarizations: public>>=
   public :: smatrix_t
 <<Polarizations: types>>=
   type :: smatrix_t
      private
      integer :: dim = 0
      integer :: n_entry = 0
      integer, dimension(:,:), allocatable :: index
      complex(default), dimension(:), allocatable :: value
    contains
    <<Polarizations: smatrix: TBP>>
   end type smatrix_t
 
 @ %def smatrix_t
 @ Output.
 <<Polarizations: smatrix: TBP>>=
   procedure :: write => smatrix_write
 <<Polarizations: procedures>>=
   subroutine smatrix_write (object, unit, indent)
     class(smatrix_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent
     integer :: u, i, ind
     u = given_output_unit (unit)
     ind = 0;  if (present (indent))  ind = indent
     if (allocated (object%value)) then
        if (size (object%value) > 0) then
           do i = 1, object%n_entry
              write (u, "(1x,A,'@(')", advance="no")  repeat ("  ", ind)
              write (u, "(SP,9999(I2.1,':',1x))", advance="no") &
                   object%index(:,i)
              write (u, "('('," // FMT_19 // ",','," // FMT_19 // &
                   ",'))')")  object%value(i)
           end do
        else
           write (u, "(1x,A)", advance="no")  repeat ("  ", ind)
           write (u, "(A)")  "[empty matrix]"
        end if
     else
        write (u, "(1x,A)", advance="no")  repeat ("  ", ind)
        write (u, "(A)")  "[undefined matrix]"
     end if
   end subroutine smatrix_write
 
 @ %def smatrix_write
 @ Initialization: allocate arrays to the correct size.  We specify both the
 dimension of the matrix (if different from two, this is rather a generic
 tensor) and the number of nonvanishing entries.
 <<Polarizations: smatrix: TBP>>=
   procedure :: init => smatrix_init
 <<Polarizations: procedures>>=
   subroutine smatrix_init (smatrix, dim, n_entry)
     class(smatrix_t), intent(out) :: smatrix
     integer, intent(in) :: dim
     integer, intent(in) :: n_entry
     smatrix%dim = dim
     smatrix%n_entry = n_entry
     allocate (smatrix%index (dim, n_entry))
     allocate (smatrix%value (n_entry))
   end subroutine smatrix_init
 
 @ %def smatrix_init
 @ Fill: one entry at a time.
 <<Polarizations: smatrix: TBP>>=
   procedure :: set_entry => smatrix_set_entry
 <<Polarizations: procedures>>=
   subroutine smatrix_set_entry (smatrix, i, index, value)
     class(smatrix_t), intent(inout) :: smatrix
     integer, intent(in) :: i
     integer, dimension(:), intent(in) :: index
     complex(default), intent(in) :: value
     smatrix%index(:,i) = index
     smatrix%value(i) = value
   end subroutine smatrix_set_entry
 
 @ %def smatrix_set_entry
 @
 <<Polarizations: smatrix: TBP>>=
   procedure :: exists => smatrix_exists
 <<Polarizations: procedures>>=
   elemental function smatrix_exists (smatrix) result (exist)
     logical :: exist
     class(smatrix_t), intent(in) :: smatrix
     exist = .not. all (smatrix%value == 0)
   end function smatrix_exists
 
 @ %def smatrix_exists
 @
 \subsection{Polarization Matrix}
 As an extension of the more generic [[smatrix]] type, we implement a proper
 spin-density matrix.  After the matrix has been filled, we can fix spin type
 and multiplicity for a particle, check the matrix for consistency, and
 normalize it if necessary.
 
 TODO: This implementation does not have an antiparticle flag, just
 like the state matrix object.  We therefore cannot account for sign
 flips when using this object.
 
 TODO: The [[pure]] flag is for informational purposes only, and it
 only represents a necessary condition if spin is greater than $1/2$.
 We may either check purity for all spins or drop this.
 <<Polarizations: public>>=
   public :: pmatrix_t
 <<Polarizations: types>>=
   type, extends (smatrix_t) :: pmatrix_t
      private
      integer :: spin_type = 0
      integer :: multiplicity = 0
      logical :: massive = .true.
      integer :: chirality = 0
      real(default) :: degree = 1
      logical :: pure = .false.
    contains
    <<Polarizations: pmatrix: TBP>>
   end type pmatrix_t
 
 @ %def pmatrix_t
 @ Output, including extra data.  (The [[indent]] argument is ignored.)
 <<Polarizations: pmatrix: TBP>>=
   procedure :: write => pmatrix_write
 <<Polarizations: procedures>>=
   subroutine pmatrix_write (object, unit, indent)
     class(pmatrix_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A)")  "Polarization: spin density matrix"
     write (u, "(3x,A,I0)")  "spin type     = ", object%spin_type
     write (u, "(3x,A,I0)")  "multiplicity  = ", object%multiplicity
     write (u, "(3x,A,L1)")  "massive       = ", object%massive
     write (u, "(3x,A,I0)")  "chirality     = ", object%chirality
     write (u, "(3x,A,F10.7)")  "pol.degree    =", object%degree
     write (u, "(3x,A,L1)")  "pure state    = ", object%pure
     call object%smatrix_t%write (u, 1)
   end subroutine pmatrix_write
 
 @ %def pmatrix_write
 @ This assignment is trivial, but must be coded explicitly.
 <<Polarizations: pmatrix: TBP>>=
   generic :: assignment(=) => pmatrix_assign_from_smatrix
   procedure, private :: pmatrix_assign_from_smatrix
 <<Polarizations: procedures>>=
   subroutine pmatrix_assign_from_smatrix (pmatrix, smatrix)
     class(pmatrix_t), intent(out) :: pmatrix
     type(smatrix_t), intent(in) :: smatrix
     pmatrix%smatrix_t = smatrix
   end subroutine pmatrix_assign_from_smatrix
 
 @ %def pmatrix_assign_from_smatrix
 @ Declare spin, multiplicity, and polarization degree.  Check whether all
 entries fit, and whether this is a valid matrix.
 
 The required properties are:
 \begin{enumerate}
 \item all entries apply to the given spin and mass type
 \item the diagonal is real
 \item only the upper of corresponding off-diagonal elements is specified,
   i.e., the row index is less than the column index
 \item the trace is nonnegative and equal to the polarization degree (the
   remainder, proportional to the unit matrix, is understood to be present)
 \item the trace of the matrix square is positive and less or equal
   to the trace of the matrix itself, which is the polarization degree.
 \item If the trace of the matrix square and the trace of the matrix are unity,
   we may have a pure state.  (For spin up to $1/2$, this is actually
   sufficient.)
 \end{enumerate}
 <<Polarizations: pmatrix: TBP>>=
   procedure :: normalize => pmatrix_normalize
 <<Polarizations: procedures>>=
   subroutine pmatrix_normalize (pmatrix, flv, degree, tolerance)
     class(pmatrix_t), intent(inout) :: pmatrix
     type(flavor_t), intent(in) :: flv
     real(default), intent(in), optional :: degree
     real(default), intent(in), optional :: tolerance
     integer :: i, hmax
     logical :: fermion, ok
     real(default) :: trace, trace_sq
     real(default) :: tol
     tol = 0;  if (present (tolerance))  tol = tolerance
     pmatrix%spin_type = flv%get_spin_type ()
     pmatrix%massive = flv%get_mass () /= 0
     if (.not. pmatrix%massive) then
        if (flv%is_left_handed ()) then
           pmatrix%chirality = -1
        else if (flv%is_right_handed ()) then
           pmatrix%chirality = +1
        end if
     end if
     if (pmatrix%spin_type == SCALAR) then
        pmatrix%multiplicity = 1
     else if (pmatrix%massive) then
        pmatrix%multiplicity = pmatrix%spin_type
     else if (pmatrix%chirality == 0) then
        pmatrix%multiplicity = 2
     else
        pmatrix%multiplicity = 1
     end if
     if (present (degree)) then
        if (degree < 0 .or. degree > 1) &
             call msg_error ("polarization degree must be between 0 and 1")
        pmatrix%degree = degree
     end if
     if (size (pmatrix%index, 1) /= 2)  call error ("wrong array rank")
     fermion = mod (pmatrix%spin_type, 2) == 0
     hmax = pmatrix%spin_type / 2
     if (pmatrix%n_entry > 0) then
        if (fermion) then
           if (pmatrix%massive) then
              ok = all (pmatrix%index /= 0) &
                   .and. all (abs (pmatrix%index) <= hmax)
           else if (pmatrix%chirality == -1) then
              ok = all (pmatrix%index == -hmax)
           else if (pmatrix%chirality == +1) then
              ok = all (pmatrix%index == +hmax)
           else
              ok = all (abs (pmatrix%index) == hmax)
           end if
        else
           if (pmatrix%massive) then
              ok = all (abs (pmatrix%index) <= hmax)
           else
              ok = all (abs (pmatrix%index) == hmax)
           end if
        end if
        if (.not. ok)  call error ("illegal index value")
     else
        pmatrix%degree = 0
        pmatrix%pure = pmatrix%multiplicity == 1
        return
     end if
     trace = 0
     do i = 1, pmatrix%n_entry
        associate (index => pmatrix%index(:,i), value => pmatrix%value(i))
          if (index(1) == index(2)) then
             if (abs (aimag (value)) > tol)  call error ("diagonal must be real")
             value = real (value, kind=default)
             trace = trace + value
 
          else if (any (pmatrix%index(1,:) == index(2) &
               .and.    pmatrix%index(2,:) == index(1))) then
             call error ("redundant off-diagonal entry")
          else if (index(2) < index (1)) then
             index = index([2,1])
             value = conjg (value)
          end if
        end associate
     end do
     if (abs (trace) <= tol)  call error ("trace must not vanish")
     trace = real (trace, kind=default)
     pmatrix%value = pmatrix%value / trace * pmatrix%degree
     trace_sq = (1 - pmatrix%degree ** 2) / pmatrix%multiplicity
     do i = 1, pmatrix%n_entry
        associate (index => pmatrix%index(:,i), value => pmatrix%value(i))
          if (index(1) == index(2)) then
             trace_sq = trace_sq + abs (value) ** 2
          else
             trace_sq = trace_sq + 2 * abs (value) ** 2
          end if
        end associate
     end do
     if (pmatrix%multiplicity == 1) then
        pmatrix%pure = .true.
     else if (abs (trace_sq - 1) <= tol) then
        pmatrix%pure = .true.
     else if (trace_sq - 1 > tol .or. trace_sq < -tol) then
        print *, "Trace of matrix square = ", trace_sq
        call error ("not permissible as density matrix")
     end if
   contains
     subroutine error (msg)
       character(*), intent(in) :: msg
       call pmatrix%write ()
       call msg_fatal ("Spin density matrix: " // msg)
     end subroutine error
   end subroutine pmatrix_normalize
 
 @ %def pmatrix_normalize
 @
 A polarized matrix is defined as one with a positive polarization degree, even
 if the actual matrix is trivial.
 <<Polarizations: pmatrix: TBP>>=
   procedure :: is_polarized => pmatrix_is_polarized
 <<Polarizations: procedures>>=
   elemental function pmatrix_is_polarized (pmatrix) result (flag)
     class(pmatrix_t), intent(in) :: pmatrix
     logical :: flag
     flag = pmatrix%degree > 0
   end function pmatrix_is_polarized
 
 @ %def pmatrix_is_polarized
 @
 Check if there are only diagonal entries.
 <<Polarizations: pmatrix: TBP>>=
   procedure :: is_diagonal => pmatrix_is_diagonal
 <<Polarizations: procedures>>=
   elemental function pmatrix_is_diagonal (pmatrix) result (flag)
     class(pmatrix_t), intent(in) :: pmatrix
     logical :: flag
     flag = all (pmatrix%index(1,:) == pmatrix%index(2,:))
   end function pmatrix_is_diagonal
 
 @ %def pmatrix_is_diagonal
 @
 Check if there are only diagonal entries.
 <<Polarizations: pmatrix: TBP>>=
   procedure :: get_simple_pol => pmatrix_get_simple_pol
 <<Polarizations: procedures>>=
   elemental function pmatrix_get_simple_pol (pmatrix) result (pol)
     class(pmatrix_t), intent(in) :: pmatrix
     real(default) :: pol
     if (pmatrix%is_polarized ()) then
        select case (size (pmatrix%value))
        case (0)
           pol = 0
        case (1)
           pol = pmatrix%index (1,1) * pmatrix%degree
        case (2)
           pol = 42
        end select
     else
        pol = 0
     end if
   end function pmatrix_get_simple_pol
 
 @ %def pmatrix_get_simple_pol
 @
 \subsection{Data Transformation}
 Create a [[polarization_t]] object from the contents of a normalized
 [[pmatrix_t]] object.  We scan the entries as present in [[pmatrix]] and
 transform them into a density matrix, if necessary.  The density
 matrix then initializes the Bloch vector.  This is
 analogous to [[polarization_init_state_matrix]].
 
 There is a subtlety associated with massless particles.  Since the
 [[pmatrix]] doesn't contain the full density matrix but just the
 nontrivial part, we have to initialize the polarization object with
 the massless equipartion, which contains nonzero entries for the
 Cartan generators.  The [[set]] method therefore should not erase
 those initial contents.  This is a constraint for the implementation
 of [[set]], as applied to the Bloch vector.
 
 TODO: As mentioned above, [[pmatrix_t]] does not support an
 antiparticle flag.
 <<Polarizations: polarization: TBP>>=
   procedure :: init_pmatrix => polarization_init_pmatrix
 <<Polarizations: procedures>>=
   subroutine polarization_init_pmatrix (pol, pmatrix)
     class(polarization_t), intent(out) :: pol
     type(pmatrix_t), intent(in) :: pmatrix
     integer :: d, i, j, k, h1, h2
     complex(default), dimension(:,:), allocatable :: r
     call pol%init_generic ( &
          spin_type = pmatrix%spin_type, &
          multiplicity = pmatrix%multiplicity, &
          anti = .false., &                     !!! SUFFICIENT?
          left_handed = pmatrix%chirality < 0, &
          right_handed = pmatrix%chirality > 0)
     if (pol%bv%is_polarized ()) then
        d = pol%bv%get_n_states ()
        allocate (r (d, d), source = (0._default, 0._default))
        if (d == pmatrix%multiplicity) then
           do i = 1, d
              r(i,i) = (1 - pmatrix%degree) / d
           end do
        else if (d > pmatrix%multiplicity) then
           r(1,1) = (1 - pmatrix%degree) / 2
           r(d,d) = r(1,1)
        end if
        do k = 1, size (pmatrix%value)
           h1 = pmatrix%index(1,k)
           h2 = pmatrix%index(2,k)
           i = pol%bv%hel_index (h1)
           j = pol%bv%hel_index (h2)
           r(i,j) = r(i,j) + pmatrix%value(k)
           r(j,i) = conjg (r(i,j))
        end do
        call pol%bv%set (r)
     end if
   end subroutine polarization_init_pmatrix
 
 @ %def polarization_init_pmatrix
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[polarizations_ut.f90]]>>=
 <<File header>>
 
 module polarizations_ut
   use unit_tests
   use polarizations_uti
 
 <<Standard module head>>
 
 <<Polarizations: public test>>
 
 contains
 
 <<Polarizations: test driver>>
 
 end module polarizations_ut
 @ %def polarizations_ut
 @
 <<[[polarizations_uti.f90]]>>=
 <<File header>>
 
 module polarizations_uti
 
 <<Use kinds>>
   use flavors
   use model_data
 
   use polarizations
 
 <<Standard module head>>
 
 <<Polarizations: test declarations>>
 
 contains
 
 <<Polarizations: tests>>
 
 end module polarizations_uti
 @ %def polarizations_ut
 @ API: driver for the unit tests below.
 <<Polarizations: public test>>=
   public :: polarizations_test
 <<Polarizations: test driver>>=
   subroutine polarizations_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Polarizations: execute tests>>
   end subroutine polarizations_test
 
 @  %def polarizations_test
 @
 \subsubsection{Polarization type}
 Checking the setup for polarization.
 <<Polarizations: execute tests>>=
   call test (polarization_1, "polarization_1", &
        "check polarization setup", &
        u, results)
 <<Polarizations: test declarations>>=
   public :: polarization_1
 <<Polarizations: tests>>=
   subroutine polarization_1 (u)
     use os_interface
     integer, intent(in) :: u
     type(model_data_t), target :: model
     type(polarization_t) :: pol
     type(flavor_t) :: flv
     real(default), dimension(3) :: alpha
     real(default) :: r, theta, phi
     real(default), parameter :: tolerance = 1.E-14_default
 
     write (u, "(A)")  "* Test output: polarization_1"
     write (u, "(A)")  "*   Purpose: test polarization setup"
     write (u, "(A)")
 
     write (u, "(A)")  "* Reading model file"
     write (u, "(A)")
 
     call model%init_sm_test ()
 
     write (u, "(A)") "* Unpolarized fermion"
     write (u, "(A)")
 
     call flv%init (1, model)
     call pol%init_unpolarized (flv)
     call pol%write (u, state_matrix = .true.)
     write (u, "(A,L1)")  "   diagonal =", pol%is_diagonal ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Unpolarized fermion"
     write (u, "(A)")
 
     call pol%init_circular (flv, 0._default)
     call pol%write (u, state_matrix = .true., all_states = .false.)
 
     write (u, "(A)")
     write (u, "(A)")  "* Transversally polarized fermion, phi=0"
     write (u, "(A)")
 
     call pol%init_transversal (flv, 0._default, 1._default)
     call pol%write (u, state_matrix = .true.)
     write (u, "(A,L1)")  "   diagonal =", pol%is_diagonal ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Transversally polarized fermion, phi=0.9, frac=0.8"
     write (u, "(A)")
 
     call pol%init_transversal (flv, 0.9_default, 0.8_default)
     call pol%write (u, state_matrix = .true.)
     write (u, "(A,L1)")  "   diagonal =", pol%is_diagonal ()
 
     write (u, "(A)")
     write (u, "(A)") "* All polarization directions of a fermion"
     write (u, "(A)")
 
     call pol%init_generic (flv)
     call pol%write (u, state_matrix = .true.)
 
 
     call flv%init (21, model)
 
     write (u, "(A)")
     write (u, "(A)")  "* Circularly polarized gluon, frac=0.3"
     write (u, "(A)")
 
     call pol%init_circular (flv, 0.3_default)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
 
 
     call flv%init (23, model)
 
     write (u, "(A)")
     write (u, "(A)") "* Circularly polarized massive vector, frac=-0.7"
     write (u, "(A)")
 
     call pol%init_circular (flv,  -0.7_default)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Circularly polarized massive vector"
     write (u, "(A)")
 
     call pol%init_circular (flv, 1._default)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Longitudinally polarized massive vector, frac=0.4"
     write (u, "(A)")
 
     call pol%init_longitudinal (flv, 0.4_default)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Longitudinally polarized massive vector"
     write (u, "(A)")
 
     call pol%init_longitudinal (flv, 1._default)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Diagonally polarized massive vector"
     write (u, "(A)")
 
     call pol%init_diagonal &
          (flv, [2._default, 1._default, 0._default])
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
 
     write (u, "(A)")
     write (u, "(A)")  "* All polarization directions of a massive vector"
     write (u, "(A)")
 
     call pol%init_generic (flv)
     call pol%write (u, state_matrix = .true.)
     call flv%init (21, model)
 
     write (u, "(A)")
     write (u, "(A)")  "* Axis polarization (0.2, 0.4, 0.6)"
     write (u, "(A)")
 
     alpha = [0.2_default, 0.4_default, 0.6_default]
     call pol%init_axis (flv, alpha)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
 
     write (u, "(A)")
     write (u, "(1X,A)")  "Recovered axis:"
     alpha = pol%get_axis ()
     write (u, "(3(1X,F10.7))")  alpha
 
     write (u, "(A)")
     write (u, "(A)")  "* Angle polarization (0.5, 0.6, -1)"
     r = 0.5_default
     theta = 0.6_default
     phi = -1._default
     call pol%init_angles (flv, r, theta, phi)
     write (u, "(A)")
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
 
     write (u, "(A)")
     write (u, "(1X,A)")  "Recovered parameters (r, theta, phi):"
     call pol%to_angles (r, theta, phi)
     write (u, "(3(1x,F10.7))")  r, theta, phi
 
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: polarization_1"
 
   end subroutine polarization_1
 
 @ %def polarization_1
 @
 \subsubsection{Sparse-Matrix type}
 Use a sparse density matrix universally as the input for setting up
 polarization.
 <<Polarizations: execute tests>>=
   call test (polarization_2, "polarization_2", &
        "matrix polarization setup", &
        u, results)
 <<Polarizations: test declarations>>=
   public :: polarization_2
 <<Polarizations: tests>>=
   subroutine polarization_2 (u)
     use os_interface
     integer, intent(in) :: u
     type(model_data_t), target :: model
     type(flavor_t) :: flv
     type(polarization_t) :: pol
     real(default), dimension(3) :: alpha
     type(pmatrix_t) :: pmatrix
     real(default), parameter :: tolerance = 1e-8_default
 
     write (u, "(A)")  "* Test output: polarization_2"
     write (u, "(A)")  "*   Purpose: matrix polarization setup"
     write (u, "(A)")
 
     write (u, "(A)")  "* Reading model file"
     write (u, "(A)")
 
     call model%init_sm_test ()
 
     write (u, "(A)") "* Unpolarized fermion"
     write (u, "(A)")
 
     call flv%init (1, model)
     call pmatrix%init (2, 0)
     call pmatrix%normalize (flv, 0._default, tolerance)
     call pmatrix%write (u)
     write (u, *)
     write (u, "(1x,A,L1)")  "polarized = ", pmatrix%is_polarized ()
     write (u, "(1x,A,L1)")  "diagonal = ", pmatrix%is_diagonal ()
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
     ! call pol%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Transversally polarized fermion, phi=0"
     write (u, "(A)")
 
     call pmatrix%init (2, 3)
     call pmatrix%set_entry (1, [-1,-1], (1._default, 0._default))
     call pmatrix%set_entry (2, [+1,+1], (1._default, 0._default))
     call pmatrix%set_entry (3, [-1,+1], (1._default, 0._default))
     call pmatrix%normalize (flv, 1._default, tolerance)
     call pmatrix%write (u)
     write (u, *)
     write (u, "(1x,A,L1)")  "polarized = ", pmatrix%is_polarized ()
     write (u, "(1x,A,L1)")  "diagonal = ", pmatrix%is_diagonal ()
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
     ! call pol%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Transversally polarized fermion, phi=0.9, frac=0.8"
     write (u, "(A)")
 
     call pmatrix%init (2, 3)
     call pmatrix%set_entry (1, [-1,-1], (1._default, 0._default))
     call pmatrix%set_entry (2, [+1,+1], (1._default, 0._default))
     call pmatrix%set_entry (3, [-1,+1], exp ((0._default, -0.9_default)))
     call pmatrix%normalize (flv, 0.8_default, tolerance)
     call pmatrix%write (u)
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true.)
     ! call pol%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Left-handed massive fermion, frac=1"
     write (u, "(A)")
 
     call flv%init (11, model)
     call pmatrix%init (2, 1)
     call pmatrix%set_entry (1, [-1,-1], (1._default, 0._default))
     call pmatrix%normalize (flv, 1._default, tolerance)
     call pmatrix%write (u)
     write (u, *)
     write (u, "(1x,A,L1)")  "polarized = ", pmatrix%is_polarized ()
     write (u, "(1x,A,L1)")  "diagonal = ", pmatrix%is_diagonal ()
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
     ! call pol%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Left-handed massive fermion, frac=0.8"
     write (u, "(A)")
 
     call flv%init (11, model)
     call pmatrix%init (2, 1)
     call pmatrix%set_entry (1, [-1,-1], (1._default, 0._default))
     call pmatrix%normalize (flv, 0.8_default, tolerance)
     call pmatrix%write (u)
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
     ! call pol%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Left-handed massless fermion"
     write (u, "(A)")
 
     call flv%init (12, model)
     call pmatrix%init (2, 0)
     call pmatrix%normalize (flv, 1._default, tolerance)
     call pmatrix%write (u)
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true.)
     ! call pol%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Right-handed massless fermion, frac=0.5"
     write (u, "(A)")
 
     call flv%init (-12, model)
     call pmatrix%init (2, 1)
     call pmatrix%set_entry (1, [1,1], (1._default, 0._default))
     call pmatrix%normalize (flv, 0.5_default, tolerance)
     call pmatrix%write (u)
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true.)
     ! call pol%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Circularly polarized gluon, frac=0.3"
     write (u, "(A)")
 
     call flv%init (21, model)
     call pmatrix%init (2, 1)
     call pmatrix%set_entry (1, [1,1], (1._default, 0._default))
     call pmatrix%normalize (flv, 0.3_default, tolerance)
     call pmatrix%write (u)
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
     ! call pol%final ()
 
     write (u, "(A)")
     write (u, "(A)") "* Circularly polarized massive vector, frac=0.7"
     write (u, "(A)")
 
     call flv%init (23, model)
     call pmatrix%init (2, 1)
     call pmatrix%set_entry (1, [1,1], (1._default, 0._default))
     call pmatrix%normalize (flv, 0.7_default, tolerance)
     call pmatrix%write (u)
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
     ! call pol%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Circularly polarized massive vector"
     write (u, "(A)")
 
     call flv%init (23, model)
     call pmatrix%init (2, 1)
     call pmatrix%set_entry (1, [1,1], (1._default, 0._default))
     call pmatrix%normalize (flv, 1._default, tolerance)
     call pmatrix%write (u)
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
     ! call pol%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Longitudinally polarized massive vector, frac=0.4"
     write (u, "(A)")
 
     call flv%init (23, model)
     call pmatrix%init (2, 1)
     call pmatrix%set_entry (1, [0,0], (1._default, 0._default))
     call pmatrix%normalize (flv, 0.4_default, tolerance)
     call pmatrix%write (u)
     write (u, *)
     write (u, "(1x,A,L1)")  "polarized = ", pmatrix%is_polarized ()
     write (u, "(1x,A,L1)")  "diagonal = ", pmatrix%is_diagonal ()
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
     ! call pol%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Longitudinally polarized massive vector"
     write (u, "(A)")
 
     call flv%init (23, model)
     call pmatrix%init (2, 1)
     call pmatrix%set_entry (1, [0,0], (1._default, 0._default))
     call pmatrix%normalize (flv, 1._default, tolerance)
     call pmatrix%write (u)
     write (u, *)
     write (u, "(1x,A,L1)")  "polarized = ", pmatrix%is_polarized ()
     write (u, "(1x,A,L1)")  "diagonal = ", pmatrix%is_diagonal ()
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true., &
          all_states = .false., tolerance = tolerance)
     ! call pol%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Axis polarization (0.2, 0.4, 0.6)"
     write (u, "(A)")
 
     call flv%init (11, model)
     alpha = [0.2_default, 0.4_default, 0.6_default]
     alpha = alpha / sqrt (sum (alpha**2))
     call pmatrix%init (2, 3)
     call pmatrix%set_entry (1, [-1,-1], cmplx (1 - alpha(3), kind=default))
     call pmatrix%set_entry (2, [1,-1], &
          cmplx (alpha(1),-alpha(2), kind=default))
     call pmatrix%set_entry (3, [1,1], cmplx (1 + alpha(3), kind=default))
     call pmatrix%normalize (flv, 1._default, tolerance)
     call pmatrix%write (u)
     write (u, *)
 
     call pol%init_pmatrix (pmatrix)
     call pol%write (u, state_matrix = .true.)
     ! call pol%final ()
 
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: polarization_2"
 
   end subroutine polarization_2
 
 @ %def polarization_2
 @
 \clearpage
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Particles}
 This module defines the [[particle_t]] object type, and the methods
 and operations that deal with it.
 <<[[particles.f90]]>>=
 <<File header>>
 
 module particles
 
 <<Use kinds with double>>
 <<Use strings>>
   use io_units
   use format_utils, only: write_compressed_integer_array, write_separator
   use format_utils, only: pac_fmt
   use format_defs, only: FMT_16, FMT_19
   use numeric_utils
   use diagnostics
   use lorentz
   use model_data
   use flavors
   use colors
   use helicities
   use quantum_numbers
   use state_matrices
   use interactions
   use subevents
   use polarizations
   use pdg_arrays, only: is_quark, is_gluon
 
 <<Standard module head>>
 
 <<Particles: public>>
 
 <<Particles: parameters>>
 
 <<Particles: types>>
 
 <<Particles: interfaces>>
 
 contains
 
 <<Particles: procedures>>
 
 end module particles
 @ %def particles
 @
 \subsection{The particle type}
 \subsubsection{Particle status codes}
 The overall status codes (incoming/outgoing etc.) are inherited from
 the module [[subevents]].
 
 Polarization status:
 <<Particles: parameters>>=
   integer, parameter, public :: PRT_UNPOLARIZED = 0
   integer, parameter, public :: PRT_DEFINITE_HELICITY = 1
   integer, parameter, public :: PRT_GENERIC_POLARIZATION = 2
 
 @ %def PRT_UNPOLARIZED PRT_DEFINITE_HELICITY PRT_GENERIC_POLARIZATION
 @
 \subsubsection{Definition}
 The quantum numbers are flavor (from which invariant particle
 properties can be derived), color, and polarization.  The particle may
 be unpolarized.  In this case, [[hel]] and [[pol]] are unspecified.
 If it has a definite helicity, the [[hel]] component is defined.  If
 it has a generic polarization, the [[pol]] component is defined.  For
 each particle we store the four-momentum and the invariant mass
 squared, i.e., the squared norm of the four-momentum.  There is also
 an optional list of parent and child particles, for bookkeeping in
 physical events. The [[vertex]] is an optional component that consists of
 a Lorentz 4-vector, denoting the position and time of the vertex
 (displaced vertex/time). [[lifetime]] is an optional component that
 accounts for the finite lifetime $\tau$ of a decaying particle. In
 case there is no magnetic field etc., the true decay vertex of a
 particle in the detector would be $\vec{v}^\prime = \vec{v} + \tau
 \times \vec{p}/p^0$, where $p^0$ and $\vec{p}$ are the energy and
 3-momentum of the particle.
 
 <<Particles: public>>=
   public :: particle_t
 <<Particles: types>>=
   type :: particle_t
      !private
      integer :: status = PRT_UNDEFINED
      integer :: polarization = PRT_UNPOLARIZED
      type(flavor_t) :: flv
      type(color_t) :: col
      type(helicity_t) :: hel
      type(polarization_t) :: pol
      type(vector4_t) :: p = vector4_null
      real(default) :: p2 = 0
      type(vector4_t), allocatable :: vertex
      real(default), allocatable :: lifetime
      integer, dimension(:), allocatable :: parent
      integer, dimension(:), allocatable :: child
    contains
   <<Particles: particle: TBP>>
   end type particle_t
 
 @ %def particle_t
 @ Copy a particle.  (Deep copy)  This excludes the parent-child
 relations.
 <<Particles: particle: TBP>>=
   generic :: init => init_particle
   procedure :: init_particle => particle_init_particle
 <<Particles: procedures>>=
   subroutine particle_init_particle (prt_out, prt_in)
     class(particle_t), intent(out) :: prt_out
     type(particle_t), intent(in) :: prt_in
     prt_out%status = prt_in%status
     prt_out%polarization = prt_in%polarization
     prt_out%flv = prt_in%flv
     prt_out%col = prt_in%col
     prt_out%hel = prt_in%hel
     prt_out%pol = prt_in%pol
     prt_out%p = prt_in%p
     prt_out%p2 = prt_in%p2
     if (allocated (prt_in%vertex))  &
        allocate (prt_out%vertex, source=prt_in%vertex)
     if (allocated (prt_in%lifetime))  &
          allocate (prt_out%lifetime, source=prt_in%lifetime)
   end subroutine particle_init_particle
 
 @ %def particle_init_particle
 @ Initialize a particle using external information.
 <<Particles: particle: TBP>>=
   generic :: init => init_external
   procedure :: init_external => particle_init_external
 <<Particles: procedures>>=
   subroutine particle_init_external &
          (particle, status, pdg, model, col, anti_col, mom)
     class(particle_t), intent(out) :: particle
     integer, intent(in) :: status, pdg, col, anti_col
     class(model_data_t), pointer, intent(in) :: model
     type(vector4_t), intent(in) :: mom
     type(flavor_t) :: flavor
     type(color_t) :: color
     call flavor%init (pdg, model)
     call particle%set_flavor (flavor)
     call color%init_col_acl (col, anti_col)
     call particle%set_color (color)
     call particle%set_status (status)
     call particle%set_momentum (mom)
   end subroutine particle_init_external
 
 @ %def particle_init_external
 @ Initialize a particle using a single-particle state matrix which
 determines flavor, color, and polarization.  The state matrix must
 have unique flavor and color.  The factorization mode determines
 whether the particle is unpolarized, has definite helicity, or generic
 polarization.  This mode is translated into the polarization status.
 <<Particles: particle: TBP>>=
   generic :: init => init_state
   procedure :: init_state => particle_init_state
 <<Particles: procedures>>=
   subroutine particle_init_state (prt, state, status, mode)
     class(particle_t), intent(out) :: prt
     type(state_matrix_t), intent(in), target :: state
     integer, intent(in) :: status, mode
     type(state_iterator_t) :: it
     prt%status = status
     call it%init (state)
     prt%flv = it%get_flavor (1)
     if (prt%flv%is_radiated ())  prt%status = PRT_BEAM_REMNANT
     prt%col = it%get_color (1)
     select case (mode)
     case (FM_SELECT_HELICITY)
        prt%hel = it%get_helicity (1)
        if (prt%hel%is_defined ()) then
           prt%polarization = PRT_DEFINITE_HELICITY
        end if
     case (FM_FACTOR_HELICITY)
        call prt%pol%init_state_matrix (state)
        prt%polarization = PRT_GENERIC_POLARIZATION
     end select
   end subroutine particle_init_state
 
 @ %def particle_init_state
 @ Finalizer.
 <<Particles: particle: TBP>>=
   procedure :: final => particle_final
 <<Particles: procedures>>=
   subroutine particle_final (prt)
     class(particle_t), intent(inout) :: prt
     if (allocated (prt%vertex))  deallocate (prt%vertex)
     if (allocated (prt%lifetime))  deallocate (prt%lifetime)
   end subroutine particle_final
 
 @ %def particle_final
 @
 \subsubsection{I/O}
 <<Particles: particle: TBP>>=
   procedure :: write => particle_write
 <<Particles: procedures>>=
   subroutine particle_write (prt, unit, testflag, compressed, polarization)
     class(particle_t), intent(in) :: prt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: testflag, compressed, polarization
     logical :: comp, pacified, pol
     integer :: u, h1, h2
     real(default) :: pp2
     character(len=7) :: fmt
     character(len=20) :: buffer
     comp = .false.; if (present (compressed))  comp = compressed
     pacified = .false.;  if (present (testflag))  pacified = testflag
     pol = .true.;  if (present (polarization))  pol = polarization
     call pac_fmt (fmt, FMT_19, FMT_16, testflag)
     u = given_output_unit (unit);  if (u < 0)  return
     pp2 = prt%p2
     if (pacified)  call pacify (pp2, tolerance = 1E-10_default)
     select case (prt%status)
     case (PRT_UNDEFINED);    write (u, "(1x, A)", advance="no")  "[-]"
     case (PRT_BEAM);         write (u, "(1x, A)", advance="no")  "[b]"
     case (PRT_INCOMING);     write (u, "(1x, A)", advance="no")  "[i]"
     case (PRT_OUTGOING);     write (u, "(1x, A)", advance="no")  "[o]"
     case (PRT_VIRTUAL);      write (u, "(1x, A)", advance="no")  "[v]"
     case (PRT_RESONANT);     write (u, "(1x, A)", advance="no")  "[r]"
     case (PRT_BEAM_REMNANT); write (u, "(1x, A)", advance="no")  "[x]"
     end select
     write (u, "(1x)", advance="no")
     if (comp) then
        write (u, "(A7,1X)", advance="no") char (prt%flv%get_name ())
        if (pol) then
           select case (prt%polarization)
           case (PRT_DEFINITE_HELICITY)
              ! Integer helicity, assumed diagonal
              call prt%hel%get_indices (h1, h2)
              write (u, "(I2,1X)", advance="no") h1
           case (PRT_GENERIC_POLARIZATION)
              ! No space for full density matrix here
              write (u, "(A2,1X)", advance="no") "*"
           case default
              ! Blank entry if helicity is undefined
              write (u, "(A2,1X)", advance="no") " "
           end select
        end if
        write (u, "(2(I4,1X))", advance="no") &
             prt%col%get_col (), prt%col%get_acl ()
        call write_compressed_integer_array (buffer, prt%parent)
        write (u, "(A,1X)", advance="no") buffer
        call write_compressed_integer_array (buffer, prt%child)
        write (u, "(A,1X)", advance="no") buffer
        call prt%p%write(u, testflag = testflag, compressed = comp)
        write (u, "(F12.3)") pp2
     else
        call prt%flv%write (unit)
        if (prt%col%is_nonzero ()) then
           call color_write (prt%col, unit)
        end if
        if (pol) then
           select case (prt%polarization)
           case (PRT_DEFINITE_HELICITY)
              call prt%hel%write (unit)
              write (u, *)
           case (PRT_GENERIC_POLARIZATION)
              write (u, *)
              call prt%pol%write (unit, state_matrix = .true.)
           case default
              write (u, *)
           end select
        else
           write (u, *)
        end if
        call prt%p%write (unit, testflag = testflag)
        write (u, "(1x,A,1x," // fmt // ")")  "T = ", pp2
        if (allocated (prt%parent)) then
           if (size (prt%parent) /= 0) then
              write (u, "(1x,A,40(1x,I0))")  "Parents: ", prt%parent
           end if
        end if
        if (allocated (prt%child)) then
           if (size (prt%child) /= 0) then
              write (u, "(1x,A,40(1x,I0))")  "Children:", prt%child
           end if
        end if
        if (allocated (prt%vertex)) then
           write (u, "(1x,A,1x," // fmt // ")")  "Vtx t = ", prt%vertex%p(0)
           write (u, "(1x,A,1x," // fmt // ")")  "Vtx x = ", prt%vertex%p(1)
           write (u, "(1x,A,1x," // fmt // ")")  "Vtx y = ", prt%vertex%p(2)
           write (u, "(1x,A,1x," // fmt // ")")  "Vtx z = ", prt%vertex%p(3)
        end if
        if (allocated (prt%lifetime)) then
           write (u, "(1x,A,1x," // fmt // ")")  "Lifetime = ", &
                prt%lifetime
        end if
     end if
   end subroutine particle_write
 
 @ %def particle_write
 @ Binary I/O:
 <<Particles: particle: TBP>>=
   procedure :: write_raw => particle_write_raw
   procedure :: read_raw => particle_read_raw
 <<Particles: procedures>>=
   subroutine particle_write_raw (prt, u)
     class(particle_t), intent(in) :: prt
     integer, intent(in) :: u
     write (u) prt%status, prt%polarization
     call prt%flv%write_raw (u)
     call prt%col%write_raw (u)
     select case (prt%polarization)
     case (PRT_DEFINITE_HELICITY)
        call prt%hel%write_raw (u)
     case (PRT_GENERIC_POLARIZATION)
        call prt%pol%write_raw (u)
     end select
     call vector4_write_raw (prt%p, u)
     write (u) prt%p2
     write (u) allocated (prt%parent)
     if (allocated (prt%parent)) then
        write (u) size (prt%parent)
        write (u) prt%parent
     end if
     write (u) allocated (prt%child)
     if (allocated (prt%child)) then
        write (u) size (prt%child)
        write (u) prt%child
     end if
     write (u) allocated (prt%vertex)
     if (allocated (prt%vertex)) then
        call vector4_write_raw (prt%vertex, u)
     end if
     write (u) allocated (prt%lifetime)
     if (allocated (prt%lifetime)) then
        write (u) prt%lifetime
     end if
   end subroutine particle_write_raw
 
   subroutine particle_read_raw (prt, u, iostat)
     class(particle_t), intent(out) :: prt
     integer, intent(in) :: u
     integer, intent(out) :: iostat
     logical :: allocated_parent, allocated_child
     logical :: allocated_vertex, allocated_lifetime
     integer :: size_parent, size_child
     read (u, iostat=iostat) prt%status, prt%polarization
     call prt%flv%read_raw (u, iostat=iostat)
     call prt%col%read_raw (u, iostat=iostat)
     select case (prt%polarization)
     case (PRT_DEFINITE_HELICITY)
        call prt%hel%read_raw (u, iostat=iostat)
     case (PRT_GENERIC_POLARIZATION)
        call prt%pol%read_raw (u, iostat=iostat)
     end select
     call vector4_read_raw (prt%p, u, iostat=iostat)
     read (u, iostat=iostat) prt%p2
     read (u, iostat=iostat) allocated_parent
     if (allocated_parent) then
        read (u, iostat=iostat) size_parent
        allocate (prt%parent (size_parent))
        read (u, iostat=iostat) prt%parent
     end if
     read (u, iostat=iostat) allocated_child
     if (allocated_child) then
        read (u, iostat=iostat) size_child
        allocate (prt%child (size_child))
        read (u, iostat=iostat) prt%child
     end if
     read (u, iostat=iostat) allocated_vertex
     if (allocated_vertex) then
        allocate (prt%vertex)
        read (u, iostat=iostat) prt%vertex%p
     end if
     read (u, iostat=iostat) allocated_lifetime
     if (allocated_lifetime) then
        allocate (prt%lifetime)
        read (u, iostat=iostat) prt%lifetime
     end if
   end subroutine particle_read_raw
 
 @ %def particle_write_raw particle_read_raw
 @
 \subsubsection{Setting contents}
 Reset the status code.  Where applicable, set $p^2$ assuming that the
 particle is on-shell.
 <<Particles: particle: TBP>>=
   procedure :: reset_status => particle_reset_status
 <<Particles: procedures>>=
   elemental subroutine particle_reset_status (prt, status)
     class(particle_t), intent(inout) :: prt
     integer, intent(in) :: status
     prt%status = status
     select case (status)
     case (PRT_BEAM, PRT_INCOMING, PRT_OUTGOING)
        prt%p2 = prt%flv%get_mass () ** 2
     end select
   end subroutine particle_reset_status
 
 @ %def particle_reset_status
 @ The color can be given explicitly.
 <<Particles: particle: TBP>>=
   procedure :: set_color => particle_set_color
 <<Particles: procedures>>=
   elemental subroutine particle_set_color (prt, col)
     class(particle_t), intent(inout) :: prt
     type(color_t), intent(in) :: col
     prt%col = col
   end subroutine particle_set_color
 
 @ %def particle_set_color
 @ The flavor can be given explicitly.
 <<Particles: particle: TBP>>=
   procedure :: set_flavor => particle_set_flavor
 <<Particles: procedures>>=
   subroutine particle_set_flavor (prt, flv)
     class(particle_t), intent(inout) :: prt
     type(flavor_t), intent(in) :: flv
     prt%flv = flv
   end subroutine particle_set_flavor
 
 @ %def particle_set_flavor
 @ As can the helicity.
 <<Particles: particle: TBP>>=
   procedure :: set_helicity => particle_set_helicity
 <<Particles: procedures>>=
   subroutine particle_set_helicity (prt, hel)
     class(particle_t), intent(inout) :: prt
     type(helicity_t), intent(in) :: hel
     prt%hel = hel
   end subroutine particle_set_helicity
 
 @ %def particle_set_helicity
 @ And the polarization.
 <<Particles: particle: TBP>>=
   procedure :: set_pol => particle_set_pol
 <<Particles: procedures>>=
   subroutine particle_set_pol (prt, pol)
     class(particle_t), intent(inout) :: prt
     type(polarization_t), intent(in) :: pol
     prt%pol = pol
   end subroutine particle_set_pol
 
 @ %def particle_set_pol
 @ Manually set the model for the particle flavor.  This is required, e.g., if
 the particle has been read from file.
 <<Particles: particle: TBP>>=
   procedure :: set_model => particle_set_model
 <<Particles: procedures>>=
   subroutine particle_set_model (prt, model)
     class(particle_t), intent(inout) :: prt
     class(model_data_t), intent(in), target :: model
     call prt%flv%set_model (model)
   end subroutine particle_set_model
 
 @ %def particle_set_model
 @ The momentum is set independent of the quantum numbers.
 <<Particles: particle: TBP>>=
   procedure :: set_momentum => particle_set_momentum
 <<Particles: procedures>>=
   elemental subroutine particle_set_momentum (prt, p, p2, on_shell)
     class(particle_t), intent(inout) :: prt
     type(vector4_t), intent(in) :: p
     real(default), intent(in), optional :: p2
     logical, intent(in), optional :: on_shell
     prt%p = p
     if (present (on_shell)) then
        if (on_shell) then
           if (prt%flv%is_associated ()) then
              prt%p2 = prt%flv%get_mass () ** 2
              return
           end if
        end if
     end if
     if (present (p2)) then
        prt%p2 = p2
     else
        prt%p2 = p ** 2
     end if
   end subroutine particle_set_momentum
 
 @ %def particle_set_momentum
 @ Set resonance information.  This should be done after momentum
 assignment, because we need to know wheter the particle is spacelike
 or timelike.  The resonance flag is defined only for virtual
 particles.
 <<Particle: particle: TBP>>=
   procedure :: set_resonance_flag => particle_set_resonance_flag
 <<Particles: procedures>>=
   elemental subroutine particle_set_resonance_flag (prt, resonant)
     class(particle_t), intent(inout) :: prt
     logical, intent(in) :: resonant
     select case (prt%status)
     case (PRT_VIRTUAL)
        if (resonant)  prt%status = PRT_RESONANT
     end select
   end subroutine particle_set_resonance_flag
 
 @ %def particle_set_resonance_flag
 @ Set children and parents information.
 <<Particles: particle: TBP>>=
   procedure :: set_children => particle_set_children
   procedure :: set_parents => particle_set_parents
 <<Particles: procedures>>=
   subroutine particle_set_children (prt, idx)
     class(particle_t), intent(inout) :: prt
     integer, dimension(:), intent(in) :: idx
     if (allocated (prt%child))  deallocate (prt%child)
     allocate (prt%child (count (idx /= 0)))
     prt%child = pack (idx, idx /= 0)
   end subroutine particle_set_children
 
   subroutine particle_set_parents (prt, idx)
     class(particle_t), intent(inout) :: prt
     integer, dimension(:), intent(in) :: idx
     if (allocated (prt%parent))  deallocate (prt%parent)
     allocate (prt%parent (count (idx /= 0)))
     prt%parent = pack (idx, idx /= 0)
   end subroutine particle_set_parents
 
 @ %def particle_set_children particle_set_parents
 @
 <<Particles: particle: TBP>>=
   procedure :: add_child => particle_add_child
 <<Particles: procedures>>=
   subroutine particle_add_child (prt, new_child)
     class(particle_t), intent(inout) :: prt
     integer, intent(in) :: new_child
     integer, dimension(:), allocatable :: idx
     integer :: n, i
     n = prt%get_n_children()
     if (n == 0) then
        call prt%set_children ([new_child])
     else
        do i = 1, n
           if (prt%child(i) == new_child) then
              return
           end if
        end do
        allocate (idx (1:n+1))
        idx(1:n) = prt%get_children ()
        idx(n+1) = new_child
        call prt%set_children (idx)
     end if
   end subroutine particle_add_child
 
 @ %def particle_add_child
 @
 <<Particles: particle: TBP>>=
   procedure :: add_children => particle_add_children
 <<Particles: procedures>>=
   subroutine particle_add_children (prt, new_child)
     class(particle_t), intent(inout) :: prt
     integer, dimension(:), intent(in) :: new_child
     integer, dimension(:), allocatable :: idx
     integer :: n
     n = prt%get_n_children()
     if (n == 0) then
        call prt%set_children (new_child)
     else
        allocate (idx (1:n+size(new_child)))
        idx(1:n) = prt%get_children ()
        idx(n+1:n+size(new_child)) = new_child
        call prt%set_children (idx)
     end if
   end subroutine particle_add_children
 
 @ %def particle_add_children
 @
 <<Particles: particle: TBP>>=
   procedure :: set_status => particle_set_status
 <<Particles: procedures>>=
   elemental subroutine particle_set_status (prt, status)
     class(particle_t), intent(inout) :: prt
     integer, intent(in) :: status
     prt%status = status
   end subroutine particle_set_status
 
 @ %def particle_set_status
 @
 <<Particles: particle: TBP>>=
   procedure :: set_polarization => particle_set_polarization
 <<Particles: procedures>>=
   subroutine particle_set_polarization (prt, polarization)
     class(particle_t), intent(inout) :: prt
     integer, intent(in) :: polarization
     prt%polarization = polarization
   end subroutine particle_set_polarization
 
 @ %def particle_set_polarization
 @
 <<Particles: particle: TBP>>=
   generic :: set_vertex => set_vertex_from_vector3, set_vertex_from_xyz, &
        set_vertex_from_vector4, set_vertex_from_xyzt
   procedure :: set_vertex_from_vector4 => particle_set_vertex_from_vector4
   procedure :: set_vertex_from_vector3 => particle_set_vertex_from_vector3
   procedure :: set_vertex_from_xyzt => particle_set_vertex_from_xyzt
   procedure :: set_vertex_from_xyz => particle_set_vertex_from_xyz
 <<Particles: procedures>>=
   subroutine particle_set_vertex_from_vector4 (prt, vertex)
     class(particle_t), intent(inout) :: prt
     type(vector4_t), intent(in) :: vertex
     if (allocated (prt%vertex)) deallocate (prt%vertex)
     allocate (prt%vertex, source=vertex)
   end subroutine particle_set_vertex_from_vector4
 
   subroutine particle_set_vertex_from_vector3 (prt, vertex)
     class(particle_t), intent(inout) :: prt
     type(vector3_t), intent(in) :: vertex
     type(vector4_t) :: vtx
     vtx = vector4_moving (0._default, vertex)
     if (allocated (prt%vertex)) deallocate (prt%vertex)
     allocate (prt%vertex, source=vtx)
   end subroutine particle_set_vertex_from_vector3
 
   subroutine particle_set_vertex_from_xyzt (prt, vx, vy, vz, t)
     class(particle_t), intent(inout) :: prt
     real(default), intent(in) :: vx, vy, vz, t
     type(vector4_t) :: vertex
     if (allocated (prt%vertex)) deallocate (prt%vertex)
     vertex = vector4_moving (t, vector3_moving ([vx, vy, vz]))
     allocate (prt%vertex, source=vertex)
   end subroutine particle_set_vertex_from_xyzt
 
   subroutine particle_set_vertex_from_xyz (prt, vx, vy, vz)
     class(particle_t), intent(inout) :: prt
     real(default), intent(in) :: vx, vy, vz
     type(vector4_t) :: vertex
     if (allocated (prt%vertex)) deallocate (prt%vertex)
     vertex = vector4_moving (0._default, vector3_moving ([vx, vy, vz]))
     allocate (prt%vertex, source=vertex)
   end subroutine particle_set_vertex_from_xyz
 
 @ %def particle_set_vertex_from_vector3
 @ %def particle_set_vertex_from_vector4
 @ %def particle_set_vertex_from_xyz
 @ %def particle_set_vertex_from_xyzt
 @ Set the lifetime of a particle.
 <<Particles: particle: TBP>>=
   procedure :: set_lifetime => particle_set_lifetime
 <<Particles: procedures>>=
   elemental subroutine particle_set_lifetime (prt, lifetime)
     class(particle_t), intent(inout) :: prt
     real(default), intent(in) :: lifetime
     if (allocated (prt%lifetime))  deallocate (prt%lifetime)
     allocate (prt%lifetime, source=lifetime)
   end subroutine particle_set_lifetime
 
 @ %def particle_set_lifetime
 @
 \subsubsection{Accessing contents}
 The status code.
 <<Particles: particle: TBP>>=
   procedure :: get_status => particle_get_status
 <<Particles: procedures>>=
   elemental function particle_get_status (prt) result (status)
     integer :: status
     class(particle_t), intent(in) :: prt
     status = prt%status
   end function particle_get_status
 
 @ %def particle_get_status
 @ Return true if the status is either [[INCOMING]],
 [[OUTGOING]] or [[RESONANT]]. [[BEAM]] is kept, if
 [[keep_beams]] is set true.
 <<Particles: particle: TBP>>=
   procedure :: is_real => particle_is_real
 <<Particles: procedures>>=
   elemental function particle_is_real (prt, keep_beams) result (flag)
     logical :: flag, kb
     class(particle_t), intent(in) :: prt
     logical, intent(in), optional :: keep_beams
     kb = .false.
     if (present (keep_beams)) kb = keep_beams
     select case (prt%status)
     case (PRT_INCOMING, PRT_OUTGOING, PRT_RESONANT)
        flag = .true.
     case (PRT_BEAM)
        flag = kb
     case default
        flag = .false.
     end select
   end function particle_is_real
 
 @ %def particle_is_real
 @
 <<Particles: particle: TBP>>=
   procedure :: is_colored => particle_is_colored
 <<Particles: procedures>>=
   elemental function particle_is_colored (particle) result (flag)
     logical :: flag
     class(particle_t), intent(in) :: particle
     flag = particle%col%is_nonzero ()
   end function particle_is_colored
 
 @ %def particle_is_colored
 @ $[90,100]$ hopefully catches all of them and not too many.
 <<Particles: particle: TBP>>=
   procedure :: is_hadronic_beam_remnant => particle_is_hadronic_beam_remnant
 <<Particles: procedures>>=
   elemental function particle_is_hadronic_beam_remnant (particle) result (flag)
     class(particle_t), intent(in) :: particle
     logical :: flag
     integer :: pdg
     pdg = particle%flv%get_pdg ()
     flag = particle%status == PRT_BEAM_REMNANT .and. &
          abs(pdg) >= 90 .and. abs(pdg) <= 100
   end function particle_is_hadronic_beam_remnant
 
 @ %def particle_is_hadronic_beam_remnant
 @
 <<Particles: particle: TBP>>=
   procedure :: is_beam_remnant => particle_is_beam_remnant
 <<Particles: procedures>>=
   elemental function particle_is_beam_remnant (particle) result (flag)
     class(particle_t), intent(in) :: particle
     logical :: flag
     flag = particle%status == PRT_BEAM_REMNANT
   end function particle_is_beam_remnant
 
 @ %def particle_is_beam_remnant
 @ Polarization status.
 <<Particles: particle: TBP>>=
   procedure :: get_polarization_status => particle_get_polarization_status
 <<Particles: procedures>>=
   elemental function particle_get_polarization_status (prt) result (status)
     integer :: status
     class(particle_t), intent(in) :: prt
     status = prt%polarization
   end function particle_get_polarization_status
 
 @ %def particle_get_polarization_status
 @ Return the PDG code from the flavor component directly.
 <<Particles: particle: TBP>>=
   procedure :: get_pdg => particle_get_pdg
 <<Particles: procedures>>=
   elemental function particle_get_pdg (prt) result (pdg)
     integer :: pdg
     class(particle_t), intent(in) :: prt
     pdg = prt%flv%get_pdg ()
   end function particle_get_pdg
 
 @ %def particle_get_pdg
 @ Return the color and anticolor quantum numbers.
 <<Particles: particle: TBP>>=
   procedure :: get_color => particle_get_color
 <<Particles: procedures>>=
   pure function particle_get_color (prt) result (col)
     integer, dimension(2) :: col
     class(particle_t), intent(in) :: prt
     col(1) = prt%col%get_col ()
     col(2) = prt%col%get_acl ()
   end function particle_get_color
 
 @ %def particle_get_color
 @ Return a copy of the polarization density matrix.
 <<Particles: particle: TBP>>=
   procedure :: get_polarization => particle_get_polarization
 <<Particles: procedures>>=
   function particle_get_polarization (prt) result (pol)
     class(particle_t), intent(in) :: prt
     type(polarization_t) :: pol
     pol = prt%pol
   end function particle_get_polarization
 
 @ %def particle_get_polarization
 @ Return the flavor, color and helicity.
 <<Particles: particle: TBP>>=
   procedure :: get_flv => particle_get_flv
   procedure :: get_col => particle_get_col
   procedure :: get_hel => particle_get_hel
 <<Particles: procedures>>=
   function particle_get_flv (prt) result (flv)
     class(particle_t), intent(in) :: prt
     type(flavor_t) :: flv
     flv = prt%flv
   end function particle_get_flv
 
   function particle_get_col (prt) result (col)
     class(particle_t), intent(in) :: prt
     type(color_t) :: col
     col = prt%col
   end function particle_get_col
 
   function particle_get_hel (prt) result (hel)
     class(particle_t), intent(in) :: prt
     type(helicity_t) :: hel
     hel = prt%hel
   end function particle_get_hel
 
 @ %def particle_get_flv particle_get_col particle_get_hel
 @ Return the helicity (if defined and diagonal).
 <<Particles: particle: TBP>>=
   procedure :: get_helicity => particle_get_helicity
 <<Particles: procedures>>=
   elemental function particle_get_helicity (prt) result (hel)
     integer :: hel
     integer, dimension(2) :: hel_arr
     class(particle_t), intent(in) :: prt
     hel = 0
     if (prt%hel%is_defined () .and. prt%hel%is_diagonal ()) then
        hel_arr = prt%hel%to_pair ()
        hel = hel_arr (1)
     end if
   end function particle_get_helicity
 
 @ %def particle_get_helicity
 @ Return the number of children/parents
 <<Particles: particle: TBP>>=
   procedure :: get_n_parents => particle_get_n_parents
   procedure :: get_n_children => particle_get_n_children
 <<Particles: procedures>>=
   elemental function particle_get_n_parents (prt) result (n)
     integer :: n
     class(particle_t), intent(in) :: prt
     if (allocated (prt%parent)) then
        n = size (prt%parent)
     else
        n = 0
     end if
   end function particle_get_n_parents
 
   elemental function particle_get_n_children (prt) result (n)
     integer :: n
     class(particle_t), intent(in) :: prt
     if (allocated (prt%child)) then
        n = size (prt%child)
     else
        n = 0
     end if
   end function particle_get_n_children
 
 @ %def particle_get_n_parents particle_get_n_children
 @ Return the array of parents/children.
 <<Particles: particle: TBP>>=
   procedure :: get_parents => particle_get_parents
   procedure :: get_children => particle_get_children
 <<Particles: procedures>>=
   function particle_get_parents (prt) result (parent)
     class(particle_t), intent(in) :: prt
     integer, dimension(:), allocatable :: parent
     if (allocated (prt%parent)) then
        allocate (parent (size (prt%parent)))
        parent = prt%parent
     else
        allocate (parent (0))
     end if
   end function particle_get_parents
 
   function particle_get_children (prt) result (child)
     class(particle_t), intent(in) :: prt
     integer, dimension(:), allocatable :: child
     if (allocated (prt%child)) then
        allocate (child (size (prt%child)))
        child = prt%child
     else
        allocate (child (0))
     end if
   end function particle_get_children
 
 @ %def particle_get_children
 @
 <<Particles: particle: TBP>>=
   procedure :: has_children => particle_has_children
 <<Particles: procedures>>=
   elemental function particle_has_children (prt) result (has_children)
     logical :: has_children
     class(particle_t), intent(in) :: prt
     has_children = .false.
     if (allocated (prt%child)) then
        has_children = size (prt%child) > 0
     end if
   end function particle_has_children
 
 @ %def particle_has_children
 @
 <<Particles: particle: TBP>>=
   procedure :: has_parents => particle_has_parents
 <<Particles: procedures>>=
   elemental function particle_has_parents (prt) result (has_parents)
     logical :: has_parents
     class(particle_t), intent(in) :: prt
     has_parents = .false.
     if (allocated (prt%parent)) then
        has_parents = size (prt%parent) > 0
     end if
   end function particle_has_parents
 
 @ %def particle_has_parents
 @ Return momentum and momentum squared.
 <<Particles: particle: TBP>>=
   procedure :: get_momentum => particle_get_momentum
   procedure :: get_p2 => particle_get_p2
 <<Particles: procedures>>=
   elemental function particle_get_momentum (prt) result (p)
     type(vector4_t) :: p
     class(particle_t), intent(in) :: prt
     p = prt%p
   end function particle_get_momentum
 
   elemental function particle_get_p2 (prt) result (p2)
     real(default) :: p2
     class(particle_t), intent(in) :: prt
     p2 = prt%p2
   end function particle_get_p2
 
 @ %def particle_get_momentum particle_get_p2
 @ Return the particle vertex, if allocated.
 <<Particles: particle: TBP>>=
   procedure :: get_vertex => particle_get_vertex
 <<Particles: procedures>>=
   elemental function particle_get_vertex (prt) result (vtx)
     type(vector4_t) :: vtx
     class(particle_t), intent(in) :: prt
     if (allocated (prt%vertex)) then
        vtx = prt%vertex
     else
        vtx = vector4_null
     end if
   end function particle_get_vertex
 
 @ %def particle_get_vertex
 @ Return the lifetime of a particle.
 <<Particles: particle: TBP>>=
   procedure :: get_lifetime => particle_get_lifetime
 <<Particles: procedures>>=
   elemental function particle_get_lifetime (prt) result (lifetime)
     real(default) :: lifetime
     class(particle_t), intent(in) :: prt
     if (allocated (prt%lifetime)) then
        lifetime = prt%lifetime
     else
        lifetime = 0
     end if
   end function particle_get_lifetime
 
 @ %def particle_get_lifetime
 @
 <<Particles: particle: TBP>>=
   procedure :: momentum_to_pythia6 => particle_momentum_to_pythia6
 <<Particles: procedures>>=
   pure function particle_momentum_to_pythia6 (prt) result (p)
     real(double), dimension(1:5) :: p
     class(particle_t), intent(in) :: prt
     p = prt%p%to_pythia6 (sqrt (prt%p2))
   end function particle_momentum_to_pythia6
 
 @ %def particle_momentum_to_pythia6
 @
 \subsection{Particle sets}
 A particle set is what is usually called an event: an array of
 particles.  The individual particle entries carry momentum, quantum
 numbers, polarization, and optionally connections.  There is (also
 optionally) a correlated state-density matrix that maintains spin
 correlations that are lost in the individual particle entries.
 
 TODO: consider making this opaque (PRIVATE), might require some additional
 access methods.
 <<Particles: public>>=
   public :: particle_set_t
 <<Particles: types>>=
   type :: particle_set_t
      ! private !!! 
      integer :: n_beam = 0
      integer :: n_in  = 0
      integer :: n_vir = 0
      integer :: n_out = 0
      integer :: n_tot = 0
      integer :: factorization_mode = FM_IGNORE_HELICITY
      type(particle_t), dimension(:), allocatable :: prt
      type(state_matrix_t) :: correlated_state
    contains
    <<Particles: particle set: TBP>>
   end type particle_set_t
 
 @ %def particle_set_t
 @ A particle set can be initialized from an interaction or from a
 HepMC event record.
 <<Particles: particle set: TBP>>=
   generic :: init => init_interaction
   procedure :: init_interaction => particle_set_init_interaction
 @ When a particle set is initialized from a given interaction, we have
 to determine the branch within the original state matrix that fixes
 the particle quantum numbers.  This is done with the appropriate
 probabilities, based on a random number [[x]].  The [[mode]]
 determines whether the individual particles become unpolarized, or
 take a definite (diagonal) helicity, or acquire single-particle
 polarization matrices.  The flag [[keep_correlations]] tells whether
 the spin-correlation matrix is to be calculated and stored in addition
 to the particles.  The flag [[keep_virtual]] tells whether virtual
 particles should be dropped.  Note that if virtual particles are
 dropped, the spin-correlation matrix makes no sense, and parent-child
 relations are not set.
 
 For a correct disentangling of color and flavor (in the presence of
 helicity), we consider two interactions.  [[int]] has no color
 information, and is used to select a flavor state.  Consequently, we
 trace over helicities here.  [[int_flows]] contains color-flow and
 potentially helicity information, but is useful only after the flavor
 combination has been chosen.  So this interaction is used to select
 helicity and color, but restricted to the selected flavor combination.
 
 [[int]] and [[int_flows]] may be identical if there is only a single
 (or no) color flow.  If there is just a single flavor combination,
 [[x(1)]] can be set to zero.
 
 The current algorithm of evaluator convolution requires that the beam
 particles are assumed outgoing (in the beam interaction) and become
 virtual in all derived interactions.  In the particle set they should
 be re-identified as incoming.  The optional integer [[n_incoming]]
 can be used to perform this correction.
 
 The flag [[is_valid]] is false if factorization of the state is not
 possible, in particular if the squared matrix element is zero.
 <<Particles: procedures>>=
   subroutine particle_set_init_interaction &
        (particle_set, is_valid, int, int_flows, mode, x, &
         keep_correlations, keep_virtual, n_incoming, qn_select)
     class(particle_set_t), intent(out) :: particle_set
     logical, intent(out) :: is_valid
     type(interaction_t), intent(in), target :: int, int_flows
     integer, intent(in) :: mode
     real(default), dimension(2), intent(in) :: x
     logical, intent(in) :: keep_correlations, keep_virtual
     integer, intent(in), optional :: n_incoming
     type(quantum_numbers_t), dimension(:), intent(in), optional :: qn_select
     type(state_matrix_t), dimension(:), allocatable, target :: flavor_state
     type(state_matrix_t), dimension(:), allocatable, target :: single_state
     integer :: n_in, n_vir, n_out, n_tot
     type(quantum_numbers_t), dimension(:,:), allocatable :: qn
     logical :: ok
     integer :: i, j
     if (present (n_incoming)) then
        n_in  = n_incoming
        n_vir = int%get_n_vir () - n_incoming
     else
        n_in  = int%get_n_in  ()
        n_vir = int%get_n_vir ()
     end if
     n_out = int%get_n_out ()
     n_tot = int%get_n_tot ()
     particle_set%n_in  = n_in
     particle_set%n_out = n_out
     if (keep_virtual) then
        particle_set%n_vir = n_vir
        particle_set%n_tot = n_tot
     else
        particle_set%n_vir = 0
        particle_set%n_tot = n_in + n_out
     end if
     particle_set%factorization_mode = mode
     allocate (qn (n_tot, 1))
     if (.not. present (qn_select)) then
        call int%factorize &
             (FM_IGNORE_HELICITY, x(1), is_valid, flavor_state)
        do i = 1, n_tot
           qn(i,:) = flavor_state(i)%get_quantum_number (1)
        end do
     else
        do i = 1, n_tot
           qn(i,:) = qn_select(i)
        end do
     end if
     if (keep_correlations .and. keep_virtual) then
        call particle_set%correlated_state%final ()
        call int_flows%factorize (mode, x(2), ok, &
             single_state, particle_set%correlated_state, qn(:,1))
     else
        call int_flows%factorize (mode, x(2), ok, &
             single_state, qn_in=qn(:,1))
     end if
     is_valid = is_valid .and. ok
     allocate (particle_set%prt (particle_set%n_tot))
     j = 1
     do i = 1, n_tot
        if (i <= n_in) then
           call particle_set%prt(j)%init (single_state(i), PRT_INCOMING, mode)
           call particle_set%prt(j)%set_momentum (int%get_momentum (i))
        else if (i <= n_in + n_vir) then
           if (.not. keep_virtual)  cycle
           call particle_set%prt(j)%init &
                (single_state(i), PRT_VIRTUAL, mode)
           call particle_set%prt(j)%set_momentum (int%get_momentum (i))
        else
           call particle_set%prt(j)%init (single_state(i), PRT_OUTGOING, mode)
           call particle_set%prt(j)%set_momentum &
                (int%get_momentum (i), on_shell = .true.)
        end if
        if (keep_virtual) then
           call particle_set%prt(j)%set_children &
                (interaction_get_children (int, i))
           call particle_set%prt(j)%set_parents &
                (interaction_get_parents (int, i))
        end if
        j = j + 1
     end do
     if (keep_virtual) then
        call particle_set_resonance_flag &
             (particle_set%prt, int%get_resonance_flags ())
     end if
     if (allocated (flavor_state)) then
        do i = 1, size(flavor_state)
           call flavor_state(i)%final ()
        end do
     end if
     do i = 1, size(single_state)
        call single_state(i)%final ()
     end do
   end subroutine particle_set_init_interaction
 
 @ %def particle_set_init_interaction
 @ Duplicate generic binding, to make sure that assignment works as it should.
 <<Particles: particle set: TBP>>=
   generic :: assignment(=) => init_particle_set
   generic :: init => init_particle_set
   procedure :: init_particle_set => particle_set_init_particle_set
 <<Particles: procedures>>=
   subroutine particle_set_init_particle_set (pset_out, pset_in)
     class(particle_set_t), intent(out) :: pset_out
     type(particle_set_t), intent(in) :: pset_in
     integer :: i
     pset_out%n_beam = pset_in%n_beam
     pset_out%n_in   = pset_in%n_in
     pset_out%n_vir  = pset_in%n_vir
     pset_out%n_out  = pset_in%n_out
     pset_out%n_tot  = pset_in%n_tot
     pset_out%factorization_mode = pset_in%factorization_mode
     if (allocated (pset_in%prt)) then
        allocate (pset_out%prt (size (pset_in%prt)))
        do i = 1, size (pset_in%prt)
           pset_out%prt(i) = pset_in%prt(i)
        end do
     end if
     pset_out%correlated_state = pset_in%correlated_state
   end subroutine particle_set_init_particle_set
 
 @ %def particle_set_init_particle_set
 @ Manually set the model for the stored particles.
 <<Particles: particle set: TBP>>=
   procedure :: set_model => particle_set_set_model
 <<Particles: procedures>>=
   subroutine particle_set_set_model (particle_set, model)
     class(particle_set_t), intent(inout) :: particle_set
     class(model_data_t), intent(in), target :: model
     integer :: i
     do i = 1, particle_set%n_tot
        call particle_set%prt(i)%set_model (model)
     end do
     call particle_set%correlated_state%set_model (model)
   end subroutine particle_set_set_model
 
 @ %def particle_set_set_model
 @ Pointer components are hidden inside the particle polarization, and
 in the correlated state matrix.
 <<Particles: particle set: TBP>>=
   procedure :: final => particle_set_final
 <<Particles: procedures>>=
   subroutine particle_set_final (particle_set)
     class(particle_set_t), intent(inout) :: particle_set
     integer :: i
     if (allocated (particle_set%prt)) then
        do i = 1, size(particle_set%prt)
           call particle_set%prt(i)%final ()
        end do
        deallocate (particle_set%prt)
     end if
     call particle_set%correlated_state%final ()
   end subroutine particle_set_final
 
 @ %def particle_set_final
 @
 \subsection{Manual build}
 Basic initialization.  Just allocate with a given number of beam, incoming,
 virtual, and outgoing particles.
 <<Particles: particle set: TBP>>=
   procedure :: basic_init => particle_set_basic_init
 <<Particles: procedures>>=
   subroutine particle_set_basic_init (particle_set, n_beam, n_in, n_vir, n_out)
     class(particle_set_t), intent(out) :: particle_set
     integer, intent(in) :: n_beam, n_in, n_vir, n_out
     particle_set%n_beam = n_beam
     particle_set%n_in = n_in
     particle_set%n_vir = n_vir
     particle_set%n_out = n_out
     particle_set%n_tot = n_beam + n_in + n_vir + n_out
     allocate (particle_set%prt (particle_set%n_tot))
   end subroutine particle_set_basic_init
 
 @ %def particle_set_basic_init
 @
 Build a particle set from scratch.  This is used for testing
 purposes.  The ordering of particles in the result is
 beam-incoming-remnant-virtual-outgoing.
 
 Parent-child relations:
 \begin{itemize}
 \item
   Beams are parents of incoming and beam remnants.  The assignment is
   alternating (first beam, second beam).
 \item
   Incoming are parents of virtual and outgoing, collectively.
 \end{itemize}
 More specific settings, such as resonance histories, cannot be set
 this way.
 
 Beam-remnant particles are counted as virtual, but have a different
 status code.
 
 We assume that the [[pdg]] array has the correct size.
 <<Particles: particle set: TBP>>=
   procedure :: init_direct => particle_set_init_direct
 <<Particles: procedures>>=
   subroutine particle_set_init_direct (particle_set, &
        n_beam, n_in, n_rem, n_vir, n_out, pdg, model)
     class(particle_set_t), intent(out) :: particle_set
     integer, intent(in) :: n_beam
     integer, intent(in) :: n_in
     integer, intent(in) :: n_rem
     integer, intent(in) :: n_vir
     integer, intent(in) :: n_out
     integer, dimension(:), intent(in) :: pdg
     class(model_data_t), intent(in), target :: model
     type(flavor_t), dimension(:), allocatable :: flv
     integer :: i, k, n
     call particle_set%basic_init (n_beam, n_in, n_rem+n_vir, n_out)
     n = 0
     call particle_set%prt(n+1:n+n_beam)%reset_status (PRT_BEAM)
     do i = n+1, n+n_beam
        call particle_set%prt(i)%set_children &
             ([(k, k=i+n_beam, n+n_beam+n_in+n_rem, 2)])
     end do
     n = n + n_beam
     call particle_set%prt(n+1:n+n_in)%reset_status (PRT_INCOMING)
     do i = n+1, n+n_in
        if (n_beam > 0) then
           call particle_set%prt(i)%set_parents &
                ([i-n_beam])
        end if
        call particle_set%prt(i)%set_children &
             ([(k, k=n+n_in+n_rem+1, n+n_in+n_rem+n_vir+n_out)])
     end do
     n = n + n_in
     call particle_set%prt(n+1:n+n_rem)%reset_status (PRT_BEAM_REMNANT)
     do i = n+1, n+n_rem
        if (n_beam > 0) then
           call particle_set%prt(i)%set_parents &
                ([i-n_in-n_beam])
        end if
     end do
     n = n + n_rem
     call particle_set%prt(n+1:n+n_vir)%reset_status (PRT_VIRTUAL)
     do i = n+1, n+n_vir
        call particle_set%prt(i)%set_parents &
             ([(k, k=n-n_rem-n_in+1, n-n_rem)])
     end do
     n = n + n_vir
     call particle_set%prt(n+1:n+n_out)%reset_status (PRT_OUTGOING)
     do i = n+1, n+n_out
        call particle_set%prt(i)%set_parents &
             ([(k, k=n-n_vir-n_rem-n_in+1, n-n_vir-n_rem)])
     end do
     allocate (flv (particle_set%n_tot))
     call flv%init (pdg, model)
     do k = n_beam+n_in+1, n_beam+n_in+n_rem
        call flv(k)%tag_radiated ()
     end do
     do i = 1, particle_set%n_tot
        call particle_set%prt(i)%set_flavor (flv(i))
     end do
   end subroutine particle_set_init_direct
 
 @ %def particle_set_init_direct
 @ Copy a particle set into a new, extended one.  Use the mapping array to
 determine the new positions of particles.  The new set contains [[n_new]]
 additional entries.  Count the new, undefined particles as
 virtual.
 
 TODO: implement mapping for the state matrix.
 <<Particles: particle set: TBP>>=
   procedure :: transfer => particle_set_transfer
 <<Particles: procedures>>=
   subroutine particle_set_transfer (pset, source, n_new, map)
     class(particle_set_t), intent(out) :: pset
     class(particle_set_t), intent(in) :: source
     integer, intent(in) :: n_new
     integer, dimension(:), intent(in) :: map
     integer :: i
     call pset%basic_init &
          (source%n_beam, source%n_in, source%n_vir + n_new, source%n_out)
     do i = 1, source%n_tot
        call pset%prt(map(i))%reset_status (source%prt(i)%get_status ())
        call pset%prt(map(i))%set_flavor (source%prt(i)%get_flv ())
        call pset%prt(map(i))%set_color (source%prt(i)%get_col ())
        call pset%prt(map(i))%set_parents (map (source%prt(i)%get_parents ()))
        call pset%prt(map(i))%set_children (map (source%prt(i)%get_children ()))
     end do
   end subroutine particle_set_transfer
   
 @ %def particle_set_transfer
 @ Insert a new particle as an intermediate into a previously empty position.
 
 Flavor and status are just set.  Color is not set (but see below).
 The complicated part is reassigning parent-child relations.  The
 inserted particle comes with an array [[child]] of its children which
 are supposed to be existing particles.
 
 We first scan all particles that come before the new insertion.
 Whenever a particle has children that coincide with the children of
 the new particle, those child entries are removed.  (a) If the new
 particle has no parent entry yet, those child entries are replaced by
 the index of the new particle and simultaneously, the particle is
 registered as a parent of the new particle.  (b) If the current particle
 already has a parent entry, those child entries are removed.
 
 When this is done, the new particle is registered as the (only) parent of its
 children.
 <<Particles: particle set: TBP>>=
   procedure :: insert => particle_set_insert
 <<Particles: procedures>>=
   subroutine particle_set_insert (pset, i, status, flv, child)
     class(particle_set_t), intent(inout) :: pset
     integer, intent(in) :: i
     integer, intent(in) :: status
     type(flavor_t), intent(in) :: flv
     integer, dimension(:), intent(in) :: child
     integer, dimension(:), allocatable :: p_child, parent
     integer :: j, k, c, n_parent
     logical :: no_match
     call pset%prt(i)%reset_status (status)
     call pset%prt(i)%set_flavor (flv)
     call pset%prt(i)%set_children (child)
     n_parent = pset%prt(i)%get_n_parents ()
     do j = 1, i - 1
        p_child = pset%prt(j)%get_children ()
        no_match = .true.
        do k = 1, size (p_child)
           if (any (p_child(k) == child)) then
              if (n_parent == 0 .and. no_match) then
                 if (.not. allocated (parent)) then
                    parent = [j]
                 else
                    parent = [parent, j]
                 end if
                 p_child(k) = i
              else
                 p_child(k) = 0
              end if
              no_match = .false.
           end if
        end do
        if (.not. no_match) then
           p_child = pack (p_child, p_child /= 0)
           call pset%prt(j)%set_children (p_child)
        end if
     end do
     if (n_parent == 0) then
        call pset%prt(i)%set_parents (parent)
     end if
     do j = 1, size (child)
        c = child(j)
        call pset%prt(c)%set_parents ([i])
     end do
   end subroutine particle_set_insert
   
 @ %def particle_set_insert
 @ This should be done after completing all insertions: recover color
 assignments for the inserted particles, working backwards from
 children to parents.  A single call to the routine recovers the color
 and anticolor line indices for a single particle.
 <<Particles: particle set: TBP>>=
   procedure :: recover_color => particle_set_recover_color
 <<Particles: procedures>>=
   subroutine particle_set_recover_color (pset, i)
     class(particle_set_t), intent(inout) :: pset
     integer, intent(in) :: i
     type(color_t) :: col
     integer, dimension(:), allocatable :: child
     integer :: j
     child = pset%prt(i)%get_children ()
     if (size (child) > 0) then
        col = pset%prt(child(1))%get_col ()
        do j = 2, size (child)
           col = col .fuse. pset%prt(child(j))%get_col ()
        end do
        call pset%prt(i)%set_color (col)
     end if
   end subroutine particle_set_recover_color
        
 @ %def particle_set_recover_color
 @
 \subsection{Extract/modify contents}
 <<Particles: particle set: TBP>>=
   generic :: get_color => get_color_all
   generic :: get_color => get_color_indices
   procedure :: get_color_all => particle_set_get_color_all
   procedure :: get_color_indices => particle_set_get_color_indices
 <<Particles: procedures>>=
   function particle_set_get_color_all (particle_set) result (col)
     class(particle_set_t), intent(in) :: particle_set
     type(color_t), dimension(:), allocatable :: col
     allocate (col (size (particle_set%prt)))
     col = particle_set%prt%col
   end function particle_set_get_color_all
 
 @ %def particle_set_get_color_all
 @
 <<Particles: procedures>>=
   function particle_set_get_color_indices (particle_set, indices) result (col)
      type(color_t), dimension(:), allocatable :: col
      class(particle_set_t), intent(in) :: particle_set
      integer, intent(in), dimension(:), allocatable :: indices
      integer :: i
      allocate (col (size (indices)))
      do i = 1, size (indices)
         col(i) = particle_set%prt(indices(i))%col
      end do
   end function particle_set_get_color_indices
 
 @ %def particle_set_get_color_indices
 @ Set a single or all color components.  This is a wrapper around the
 corresponding [[particle_t]] method, with the same options.  We assume
 that the particle array is allocated.
 <<Particles: particle set: TBP>>=
   generic :: set_color => set_color_single
   generic :: set_color => set_color_indices
   generic :: set_color => set_color_all
   procedure :: set_color_single => particle_set_set_color_single
   procedure :: set_color_indices => particle_set_set_color_indices
   procedure :: set_color_all => particle_set_set_color_all
 <<Particles: procedures>>=
   subroutine particle_set_set_color_single (particle_set, i, col)
     class(particle_set_t), intent(inout) :: particle_set
     integer, intent(in) :: i
     type(color_t), intent(in) :: col
     call particle_set%prt(i)%set_color (col)
   end subroutine particle_set_set_color_single
 
   subroutine particle_set_set_color_indices (particle_set, indices, col)
     class(particle_set_t), intent(inout) :: particle_set
     integer, dimension(:), intent(in) :: indices
     type(color_t), dimension(:), intent(in) :: col
     integer :: i
     do i = 1, size (indices)
        call particle_set%prt(indices(i))%set_color (col(i))
     end do
   end subroutine particle_set_set_color_indices
 
   subroutine particle_set_set_color_all (particle_set, col)
     class(particle_set_t), intent(inout) :: particle_set
     type(color_t), dimension(:), intent(in) :: col
     call particle_set%prt%set_color (col)
   end subroutine particle_set_set_color_all
 
 @ %def particle_set_set_color
 @ Assigning particles manually may result in color mismatches.  This is
 checked here for all particles in the set.  The color object is
 compared against the color type that belongs to the flavor object.
 The return value is an allocatable array which consists of the particles
 with invalid color assignments.  If the array size is zero, all is fine.
 <<Particles: particle set: TBP>>=
   procedure :: find_prt_invalid_color => particle_set_find_prt_invalid_color
 <<Particles: procedures>>=
   subroutine particle_set_find_prt_invalid_color (particle_set, index, prt)
     class(particle_set_t), intent(in) :: particle_set
     integer, dimension(:), allocatable, intent(out) :: index
     type(particle_t), dimension(:), allocatable, intent(out), optional :: prt
     type(flavor_t) :: flv
     type(color_t) :: col
     logical, dimension(:), allocatable :: mask
     integer :: i, n, n_invalid
     n = size (particle_set%prt)
     allocate (mask (n))
     do i = 1, n
        associate (prt => particle_set%prt(i))
          flv = prt%get_flv ()
          col = prt%get_col ()
          mask(i) = flv%get_color_type () /= col%get_type ()
        end associate
     end do
     index = pack ([(i, i = 1, n)], mask)
     if (present (prt))  prt = pack (particle_set%prt, mask)
   end subroutine particle_set_find_prt_invalid_color
   
 @ %def particle_set_find_prt_invalid_color
 @ 
 <<Particles: particle set: TBP>>=
   generic :: get_momenta => get_momenta_all
   generic :: get_momenta => get_momenta_indices
   procedure :: get_momenta_all => particle_set_get_momenta_all
   procedure :: get_momenta_indices => particle_set_get_momenta_indices
 <<Particles: procedures>>=
   function particle_set_get_momenta_all (particle_set) result (p)
     class(particle_set_t), intent(in) :: particle_set
     type(vector4_t), dimension(:), allocatable :: p
     allocate (p (size (particle_set%prt)))
     p = particle_set%prt%p
   end function particle_set_get_momenta_all
 
 @ %def particle_set_get_momenta_all
 @
 <<Particles: procedures>>=
   function particle_set_get_momenta_indices (particle_set, indices) result (p)
      type(vector4_t), dimension(:), allocatable :: p
      class(particle_set_t), intent(in) :: particle_set
      integer, intent(in), dimension(:), allocatable :: indices
      integer :: i
      allocate (p (size (indices)))
      do i = 1, size (indices)
         p(i) = particle_set%prt(indices(i))%p
      end do
   end function particle_set_get_momenta_indices
 
 @ %def particle_set_get_momenta_indices
 @ Replace a single or all momenta.  This is a wrapper around the
 corresponding [[particle_t]] method, with the same options.  We assume
 that the particle array is allocated.
 <<Particles: particle set: TBP>>=
   generic :: set_momentum => set_momentum_single
   generic :: set_momentum => set_momentum_indices
   generic :: set_momentum => set_momentum_all
   procedure :: set_momentum_single => particle_set_set_momentum_single
   procedure :: set_momentum_indices => particle_set_set_momentum_indices
   procedure :: set_momentum_all => particle_set_set_momentum_all
 <<Particles: procedures>>=
   subroutine particle_set_set_momentum_single &
        (particle_set, i, p, p2, on_shell)
     class(particle_set_t), intent(inout) :: particle_set
     integer, intent(in) :: i
     type(vector4_t), intent(in) :: p
     real(default), intent(in), optional :: p2
     logical, intent(in), optional :: on_shell
     call particle_set%prt(i)%set_momentum (p, p2, on_shell)
   end subroutine particle_set_set_momentum_single
 
   subroutine particle_set_set_momentum_indices &
        (particle_set, indices, p, p2, on_shell)
     class(particle_set_t), intent(inout) :: particle_set
     integer, dimension(:), intent(in) :: indices
     type(vector4_t), dimension(:), intent(in) :: p
     real(default), dimension(:), intent(in), optional :: p2
     logical, intent(in), optional :: on_shell
     integer :: i
     if (present (p2)) then
        do i = 1, size (indices)
           call particle_set%prt(indices(i))%set_momentum (p(i), p2(i), on_shell)
        end do
     else
        do i = 1, size (indices)
           call particle_set%prt(indices(i))%set_momentum &
                (p(i), on_shell=on_shell)
        end do
     end if
   end subroutine particle_set_set_momentum_indices
 
   subroutine particle_set_set_momentum_all (particle_set, p, p2, on_shell)
     class(particle_set_t), intent(inout) :: particle_set
     type(vector4_t), dimension(:), intent(in) :: p
     real(default), dimension(:), intent(in), optional :: p2
     logical, intent(in), optional :: on_shell
     call particle_set%prt%set_momentum (p, p2, on_shell)
   end subroutine particle_set_set_momentum_all
 
 @ %def particle_set_set_momentum
 @ Recover a momentum by recombining from children, assuming that this
 is possible.  The reconstructed momentum is not projected on-shell.
 <<Particles: particle set: TBP>>=
   procedure :: recover_momentum => particle_set_recover_momentum
 <<Particles: procedures>>=
   subroutine particle_set_recover_momentum (particle_set, i)
     class(particle_set_t), intent(inout) :: particle_set
     integer, intent(in) :: i
     type(vector4_t), dimension(:), allocatable :: p
     integer, dimension(:), allocatable :: index
     index = particle_set%prt(i)%get_children ()
     p = particle_set%get_momenta (index)
     call particle_set%set_momentum (i, sum (p))
   end subroutine particle_set_recover_momentum
   
 @ %def particle_set_recover_momentum
 @
 <<Particles: particle set: TBP>>=
   procedure :: replace_incoming_momenta => particle_set_replace_incoming_momenta
 <<Particles: procedures>>=
   subroutine particle_set_replace_incoming_momenta (particle_set, p)
     class(particle_set_t), intent(inout) :: particle_set
     type(vector4_t), intent(in), dimension(:) :: p
     integer :: i, j
     i = 1
     do j = 1, particle_set%get_n_tot ()
        if (particle_set%prt(j)%get_status () == PRT_INCOMING) then
           particle_set%prt(j)%p = p(i)
           i = i + 1
           if (i > particle_set%n_in) exit
        end if
     end do
   end subroutine particle_set_replace_incoming_momenta
 
 @ %def particle_set_replace_incoming_momenta
 @
 <<Particles: particle set: TBP>>=
   procedure :: replace_outgoing_momenta => particle_set_replace_outgoing_momenta
 <<Particles: procedures>>=
   subroutine particle_set_replace_outgoing_momenta (particle_set, p)
     class(particle_set_t), intent(inout) :: particle_set
     type(vector4_t), intent(in), dimension(:) :: p
     integer :: i, j
     i = particle_set%n_in + 1
     do j = 1, particle_set%n_tot
        if (particle_set%prt(j)%get_status () == PRT_OUTGOING) then
           particle_set%prt(j)%p = p(i)
           i = i + 1
        end if
     end do
   end subroutine particle_set_replace_outgoing_momenta
 
 @ %def particle_set_replace_outgoing_momenta
 @ 
 <<Particles: particle set: TBP>>=
   procedure :: get_outgoing_momenta => particle_set_get_outgoing_momenta
 <<Particles: procedures>>=
   function particle_set_get_outgoing_momenta (particle_set) result (p)
     class(particle_set_t), intent(in) :: particle_set
     type(vector4_t), dimension(:), allocatable :: p
     integer :: i, k
     allocate (p (count (particle_set%prt%get_status () == PRT_OUTGOING)))
     k = 0
     do i = 1, size (particle_set%prt)
        if (particle_set%prt(i)%get_status () == PRT_OUTGOING) then
           k = k + 1
           p(k) = particle_set%prt(i)%get_momentum ()
        end if
     end do
   end function particle_set_get_outgoing_momenta
 
 @ %def particle_set_get_outgoing_momenta
 @
 <<Particles: particle set: TBP>>=
   procedure :: parent_add_child => particle_set_parent_add_child
 <<Particles: procedures>>=
   subroutine particle_set_parent_add_child (particle_set, parent, child)
     class(particle_set_t), intent(inout) :: particle_set
     integer, intent(in) :: parent, child
     call particle_set%prt(child)%set_parents ([parent])
     call particle_set%prt(parent)%add_child (child)
   end subroutine particle_set_parent_add_child
 
 @ %def particle_set_parent_add_child
 @ Given the [[particle_set]] before radiation, the new momenta
 [[p_radiated]], the [[emitter]] and the [[flv_radiated]] as well as the
 [[model]] and a random number [[r_color]] for chosing a color, we update
 the [[particle_set]].
 <<Particles: particle set: TBP>>=
   procedure :: build_radiation => particle_set_build_radiation
 <<Particles: procedures>>=
   subroutine particle_set_build_radiation (particle_set, p_radiated, &
      emitter, flv_radiated, model, r_color)
      class(particle_set_t), intent(inout) :: particle_set
      type(vector4_t), intent(in), dimension(:) :: p_radiated
      integer, intent(in) :: emitter
      integer, intent(in), dimension(:) :: flv_radiated
      class(model_data_t), intent(in), target :: model
      real(default), intent(in) :: r_color
      type(particle_set_t) :: new_particle_set
      type(particle_t) :: new_particle
      integer :: i
      integer :: pdg_index_emitter, pdg_index_radiation
      integer, dimension(:), allocatable :: parents, children
      type(flavor_t) :: new_flv
      logical, dimension(:), allocatable :: status_mask
      integer, dimension(:), allocatable :: &
           i_in1, i_beam1, i_remnant1, i_virt1, i_out1
      integer, dimension(:), allocatable :: &
           i_in2, i_beam2, i_remnant2, i_virt2, i_out2
      integer :: n_in1, n_beam1, n_remnant1, n_virt1, n_out1
      integer :: n_in2, n_beam2, n_remnant2, n_virt2, n_out2
      integer :: n, n_tot
      integer :: i_emitter
 
      n = particle_set%get_n_tot ()
      allocate (status_mask (n))
      do i = 1, n
         status_mask(i) = particle_set%prt(i)%get_status () == PRT_INCOMING
      end do
      n_in1 = count (status_mask)
      allocate (i_in1 (n_in1))
      i_in1 = particle_set%get_indices (status_mask)
      do i = 1, n
         status_mask(i) = particle_set%prt(i)%get_status () == PRT_BEAM
      end do
      n_beam1 = count (status_mask)
      allocate (i_beam1 (n_beam1))
      i_beam1 = particle_set%get_indices (status_mask)
      do i = 1, n
         status_mask(i) = particle_set%prt(i)%get_status () == PRT_BEAM_REMNANT
      end do
      n_remnant1 = count (status_mask)
      allocate (i_remnant1 (n_remnant1))
      i_remnant1 = particle_set%get_indices (status_mask)
      do i = 1, n
         status_mask(i) = particle_set%prt(i)%get_status () == PRT_VIRTUAL
      end do
      n_virt1 = count (status_mask)
      allocate (i_virt1 (n_virt1))
      i_virt1 = particle_set%get_indices (status_mask)
      do i = 1, n
         status_mask(i) = particle_set%prt(i)%get_status () == PRT_OUTGOING
      end do
      n_out1 = count (status_mask)
      allocate (i_out1 (n_out1))
      i_out1 = particle_set%get_indices (status_mask)
 
      n_in2 = n_in1; n_beam2 = n_beam1; n_remnant2 = n_remnant1
      n_virt2 = n_virt1 + n_out1
      n_out2 = n_out1 + 1
      n_tot = n_in2 + n_beam2 + n_remnant2 + n_virt2 + n_out2
 
      allocate (i_in2 (n_in2), i_beam2 (n_beam2), i_remnant2 (n_remnant2))
      i_in2 = i_in1; i_beam2 = i_beam1; i_remnant2 = i_remnant1
 
      allocate (i_virt2 (n_virt2))
      i_virt2(1 : n_virt1) = i_virt1
      i_virt2(n_virt1 + 1 : n_virt2) = i_out1
 
      allocate (i_out2 (n_out2))
      i_out2(1 : n_out1) = i_out1(1 : n_out1) + n_out1
      i_out2(n_out2) = n_tot
 
      new_particle_set%n_beam = n_beam2
      new_particle_set%n_in = n_in2
      new_particle_set%n_vir = n_virt2
      new_particle_set%n_out = n_out2
      new_particle_set%n_tot = n_tot
      new_particle_set%correlated_state = particle_set%correlated_state
      allocate (new_particle_set%prt (n_tot))
      if (size (i_beam1) > 0) new_particle_set%prt(i_beam2) = particle_set%prt(i_beam1)
      if (size (i_remnant1) > 0) new_particle_set%prt(i_remnant2) = particle_set%prt(i_remnant1)
      do i = 1, n_virt1
         new_particle_set%prt(i_virt2(i)) = particle_set%prt(i_virt1(i))
      end do
 
      do i = n_virt1 + 1, n_virt2
         new_particle_set%prt(i_virt2(i)) = particle_set%prt(i_out1(i - n_virt1))
         call new_particle_set%prt(i_virt2(i))%reset_status (PRT_VIRTUAL)
      end do
 
      do i = 1, n_in2
         new_particle_set%prt(i_in2(i)) = particle_set%prt(i_in1(i))
         new_particle_set%prt(i_in2(i))%p = p_radiated (i)
      end do
 
      do i = 1, n_out2 - 1
         new_particle_set%prt(i_out2(i)) = particle_set%prt(i_out1(i))
         new_particle_set%prt(i_out2(i))%p = p_radiated(i + n_in2)
         call new_particle_set%prt(i_out2(i))%reset_status (PRT_OUTGOING)
      end do
 
      call new_particle%reset_status (PRT_OUTGOING)
      call new_particle%set_momentum (p_radiated (n_in2 + n_out2))
 
      !!! Helicity and polarization handling is missing at this point
      !!! Also, no helicities or polarizations yet
      pdg_index_emitter = flv_radiated (emitter)
      pdg_index_radiation = flv_radiated (n_in2 + n_out2)
      call new_flv%init (pdg_index_radiation, model)
      i_emitter = emitter + n_virt2 + n_remnant2 + n_beam2
 
      call reassign_colors (new_particle, new_particle_set%prt(i_emitter), &
         pdg_index_radiation, pdg_index_emitter, r_color)
 
      call new_particle%set_flavor (new_flv)
      new_particle_set%prt(n_tot) = new_particle
 
      allocate (children (n_out2))
      children = i_out2
      do i = n_in2 + n_beam2 + n_remnant2 + n_virt1 + 1, n_in2 + n_beam2 + n_remnant2 + n_virt2
         call new_particle_set%prt(i)%set_children (children)
      end do
 
      !!! Set proper parents for outgoing particles
      allocate (parents (n_out1))
      parents = i_out1
      do i = n_in2 + n_beam2 + n_remnant2 + n_virt2 + 1, n_tot
         call new_particle_set%prt(i)%set_parents (parents)
      end do
      call particle_set%init (new_particle_set)
   contains
 
     <<build radiation: set color offset>>
     subroutine reassign_colors (prt_radiated, prt_emitter, i_rad, i_em, r_col)
       type(particle_t), intent(inout) :: prt_radiated, prt_emitter
       integer, intent(in) :: i_rad, i_em
       real(default), intent(in) :: r_col
       type(color_t) :: col_rad, col_em
       if (is_quark (i_em) .and. is_gluon (i_rad)) then
          call reassign_colors_qg (prt_emitter, col_rad, col_em)
       else if (is_gluon (i_em) .and. is_gluon (i_rad)) then
          call reassign_colors_gg (prt_emitter, r_col, col_rad, col_em)
       else if (is_gluon (i_em) .and. is_quark (i_rad)) then
          call reassign_colors_qq (prt_emitter, i_em, col_rad, col_em)
       else
          call msg_fatal ("Invalid splitting")
       end if
       call prt_emitter%set_color (col_em)
       call prt_radiated%set_color (col_rad)
     end subroutine reassign_colors
 
     subroutine reassign_colors_qg (prt_emitter, col_rad, col_em)
       type(particle_t), intent(in) :: prt_emitter
       type(color_t), intent(out) :: col_rad, col_em
       integer, dimension(2) :: color_rad, color_em
       integer :: i1, i2
       integer :: new_color_index
       logical :: is_anti_quark
 
       color_em = prt_emitter%get_color ()
       i1 = 1; i2 = 2
       is_anti_quark = color_em(2) /= 0
       if (is_anti_quark) then
          i1 = 2; i2 = 1
       end if
       new_color_index = color_em(i1)+1
       color_rad(i1) = color_em(i1)
       color_rad(i2) = new_color_index
       color_em(i1) = new_color_index
       call col_em%init_col_acl (color_em(1), color_em(2))
       call col_rad%init_col_acl (color_rad(1), color_rad(2))
     end subroutine reassign_colors_qg
 
     subroutine reassign_colors_gg (prt_emitter, random, col_rad, col_em)
       !!! NOT TESTED YET
       type(particle_t), intent(in) :: prt_emitter
       real(default), intent(in) :: random
       type(color_t), intent(out) :: col_rad, col_em
       integer, dimension(2) :: color_rad, color_em
       integer :: i1, i2
       integer :: new_color_index
 
       color_em = prt_emitter%get_color ()
       new_color_index = maxval (abs (color_em))
       i1 = 1; i2 = 2
       if (random < 0.5) then
          i1 = 2; i2 = 1
       end if
       color_rad(i1) = new_color_index
       color_rad(i2) = color_em(i2)
       color_em(i2) = new_color_index
       call col_em%init_col_acl (color_em(1), color_em(2))
       call col_rad%init_col_acl (color_rad(1), color_rad(2))
     end subroutine reassign_colors_gg
 
     subroutine reassign_colors_qq (prt_emitter, pdg_emitter, col_rad, col_em)
       !!! NOT TESTED YET
       type(particle_t), intent(in) :: prt_emitter
       integer, intent(in) :: pdg_emitter
       type(color_t), intent(out) :: col_rad, col_em
       integer, dimension(2) :: color_rad, color_em
       integer :: i1, i2
       logical :: is_anti_quark
 
       color_em = prt_emitter%get_color ()
       i1 = 1; i2 = 2
       is_anti_quark = pdg_emitter < 0
       if (is_anti_quark) then
          i1 = 2; i1 = 1
       end if
       color_em(i2) = 0
       color_rad(i1) = 0
       color_rad(i2) = color_em(i1)
       call col_em%init_col_acl (color_em(1), color_em(2))
       call col_rad%init_col_acl (color_rad(1), color_rad(2))
     end subroutine reassign_colors_qq
   end subroutine particle_set_build_radiation
 
 @ %def particle_set_build_radiation
 @ Increments the color indices of all particles by their maximal value to distinguish them
 from the record-keeping Born particles in the LHE-output if the virtual entries are kept.
 <<build radiation: set color offset>>=
   subroutine set_color_offset (particle_set)
     type(particle_set_t), intent(inout) :: particle_set
     integer, dimension(2) :: color
     integer :: i, i_color_max
     type(color_t) :: new_color
 
     i_color_max = 0
     do i = 1, size (particle_set%prt)
        associate (prt => particle_set%prt(i))
           if (prt%get_status () <= PRT_INCOMING) cycle
           color = prt%get_color ()
           i_color_max = maxval([i_color_max, color(1), color(2)])
        end associate
     end do
 
 
     do i = 1, size (particle_set%prt)
        associate (prt => particle_set%prt(i))
           if (prt%get_status () /= PRT_OUTGOING) cycle
           color = prt%get_color ()
           where (color /= 0) color = color + i_color_max
           call new_color%init_col_acl (color(1), color(2))
           call prt%set_color (new_color)
        end associate
     end do
   end subroutine set_color_offset
 
 @ %def set_color_offset
 @ Output (default format)
 <<Particles: particle set: TBP>>=
   procedure :: write => particle_set_write
 <<Particles: procedures>>=
   subroutine particle_set_write &
     (particle_set, unit, testflag, summary, compressed)
     class(particle_set_t), intent(in) :: particle_set
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: testflag, summary, compressed
     logical :: summ, comp, pol
     type(vector4_t) :: sum_vec
     integer :: u, i
     u = given_output_unit (unit);  if (u < 0)  return
     summ = .false.; if (present (summary)) summ = summary
     comp = .false.; if (present (compressed)) comp = compressed
     pol = particle_set%factorization_mode /= FM_IGNORE_HELICITY
     write (u, "(1x,A)") "Particle set:"
     call write_separator (u)
     if (comp) then
        if (pol) then
           write (u, &
                "((A4,1X),(A6,1X),(A7,1X),(A3),2(A4,1X),2(A20,1X),5(A12,1X))") &
                "Nr", "Status", "Flavor", "Hel", "Col", "ACol", &
                "Parents", "Children", &
                "P(0)", "P(1)", "P(2)", "P(3)", "P^2"
        else
           write (u, &
                "((A4,1X),(A6,1X),(A7,1X),2(A4,1X),2(A20,1X),5(A12,1X))") &
                "Nr", "Status", "Flavor", "Col", "ACol", &
                "Parents", "Children", &
                "P(0)", "P(1)", "P(2)", "P(3)", "P^2"
        end if
     end if
     if (particle_set%n_tot /= 0) then
        do i = 1, particle_set%n_tot
           if (comp) then
              write (u, "(I4,1X,2X)", advance="no") i
           else
              write (u, "(1x,A,1x,I0)", advance="no") "Particle", i
           end if
           call particle_set%prt(i)%write (u, testflag = testflag, &
                compressed = comp, polarization = pol)
        end do
        if (particle_set%correlated_state%is_defined ()) then
           call write_separator (u)
           write (u, *) "Correlated state density matrix:"
           call particle_set%correlated_state%write (u)
        end if
        if (summ) then
           call write_separator (u)
           write (u, "(A)", advance="no") &
                "Sum of incoming momenta: p(0:3) =     "
           sum_vec = sum (particle_set%prt%p, &
                mask=particle_set%prt%get_status () == PRT_INCOMING)
           call pacify (sum_vec, tolerance = 1E-3_default)
           call sum_vec%write (u, compressed=.true.)
           write (u, *)
           write (u, "(A)", advance="no") &
                "Sum of beam remnant momenta: p(0:3) = "
           sum_vec = sum (particle_set%prt%p, &
                mask=particle_set%prt%get_status () == PRT_BEAM_REMNANT)
           call pacify (sum_vec, tolerance = 1E-3_default)
           call sum_vec%write (u, compressed=.true.)
           write (u, *)
           write (u, "(A)", advance="no") &
                "Sum of outgoing momenta: p(0:3) =     "
           sum_vec = sum (particle_set%prt%p, &
                mask=particle_set%prt%get_status () == PRT_OUTGOING)
           call pacify (sum_vec, tolerance = 1E-3_default)
           call sum_vec%write (u, compressed=.true.)
           write (u, "(A)") ""
        end if
     else
        write (u, "(3x,A)") "[empty]"
     end if
   end subroutine particle_set_write
 
 @ %def particle_set_write
 @
 \subsection{I/O formats}
 Here, we define input/output of particle sets in various formats.
 This is the right place since particle sets contain most of the event
 information.
 
 All write/read routines take as first argument the object, as second
 argument the I/O unit which in this case is a mandatory argument.
 Then follow further event data.
 
 \subsubsection{Internal binary format}
 This format is supposed to contain the complete information, so
 the particle data set can be fully reconstructed.  The exception is
 the model part of the particle flavors; this is unassigned for the
 flavor values read from file.
 <<Particles: particle set: TBP>>=
   procedure :: write_raw => particle_set_write_raw
   procedure :: read_raw => particle_set_read_raw
 <<Particles: procedures>>=
   subroutine particle_set_write_raw (particle_set, u)
     class(particle_set_t), intent(in) :: particle_set
     integer, intent(in) :: u
     integer :: i
     write (u) &
          particle_set%n_beam, particle_set%n_in, &
          particle_set%n_vir, particle_set%n_out
     write (u) particle_set%factorization_mode
     write (u) particle_set%n_tot
     do i = 1, particle_set%n_tot
        call particle_set%prt(i)%write_raw (u)
     end do
     call particle_set%correlated_state%write_raw (u)
   end subroutine particle_set_write_raw
 
   subroutine particle_set_read_raw (particle_set, u, iostat)
     class(particle_set_t), intent(out) :: particle_set
     integer, intent(in) :: u
     integer, intent(out) :: iostat
     integer :: i
     read (u, iostat=iostat) &
          particle_set%n_beam, particle_set%n_in, &
          particle_set%n_vir, particle_set%n_out
     read (u, iostat=iostat) particle_set%factorization_mode
     read (u, iostat=iostat) particle_set%n_tot
     allocate (particle_set%prt (particle_set%n_tot))
     do i = 1, size (particle_set%prt)
        call particle_set%prt(i)%read_raw (u, iostat=iostat)
     end do
     call particle_set%correlated_state%read_raw (u, iostat=iostat)
   end subroutine particle_set_read_raw
 
 @ %def particle_set_write_raw particle_set_read_raw
 @
 \subsubsection{Get contents}
 Find parents/children of a particular particle recursively; the
 search terminates if a parent/child has status [[BEAM]], [[INCOMING]],
 [[OUTGOING]] or [[RESONANT]].
 <<Particles: particle set: TBP>>=
   procedure :: get_real_parents => particle_set_get_real_parents
   procedure :: get_real_children => particle_set_get_real_children
 <<Particles: procedures>>=
   function particle_set_get_real_parents (pset, i, keep_beams) result (parent)
     integer, dimension(:), allocatable :: parent
     class(particle_set_t), intent(in) :: pset
     integer, intent(in) :: i
     logical, intent(in), optional :: keep_beams
     logical, dimension(:), allocatable :: is_real
     logical, dimension(:), allocatable :: is_parent, is_real_parent
     logical :: kb
     integer :: j, k
     kb = .false.
     if (present (keep_beams)) kb = keep_beams
     allocate (is_real (pset%n_tot))
     is_real = pset%prt%is_real (kb)
     allocate (is_parent (pset%n_tot), is_real_parent (pset%n_tot))
     is_real_parent = .false.
     is_parent = .false.
     is_parent(pset%prt(i)%get_parents()) = .true.
     do while (any (is_parent))
        where (is_real .and. is_parent)
           is_real_parent = .true.
           is_parent = .false.
        end where
        mark_next_parent: do j = size (is_parent), 1, -1
           if (is_parent(j)) then
              is_parent(pset%prt(j)%get_parents()) = .true.
              is_parent(j) = .false.
              exit mark_next_parent
           end if
        end do mark_next_parent
     end do
     allocate (parent (count (is_real_parent)))
     j = 0
     do k = 1, size (is_parent)
        if (is_real_parent(k)) then
           j = j + 1
           parent(j) = k
        end if
     end do
   end function particle_set_get_real_parents
 
   function particle_set_get_real_children (pset, i, keep_beams) result (child)
     integer, dimension(:), allocatable :: child
     class(particle_set_t), intent(in) :: pset
     integer, intent(in) :: i
     logical, dimension(:), allocatable :: is_real
     logical, dimension(:), allocatable :: is_child, is_real_child
     logical, intent(in), optional :: keep_beams
     integer :: j, k
     logical :: kb
     kb = .false.
     if (present (keep_beams)) kb = keep_beams
     allocate (is_real (pset%n_tot))
     is_real = pset%prt%is_real (kb)
     is_real = pset%prt%is_real (kb)
     allocate (is_child (pset%n_tot), is_real_child (pset%n_tot))
     is_real_child = .false.
     is_child = .false.
     is_child(pset%prt(i)%get_children()) = .true.
     do while (any (is_child))
        where (is_real .and. is_child)
           is_real_child = .true.
           is_child = .false.
        end where
        mark_next_child: do j = 1, size (is_child)
           if (is_child(j)) then
              is_child(pset%prt(j)%get_children()) = .true.
              is_child(j) = .false.
              exit mark_next_child
           end if
        end do mark_next_child
     end do
     allocate (child (count (is_real_child)))
     j = 0
     do k = 1, size (is_child)
        if (is_real_child(k)) then
           j = j + 1
           child(j) = k
        end if
     end do
   end function particle_set_get_real_children
 
 @ %def particle_set_get_real_parents
 @ %def particle_set_get_real_children
 @ Get the [[n_tot]], [[n_in]], and [[n_out]] values out of the
 particle set.
 <<Particles: particle set: TBP>>=
   procedure :: get_n_beam => particle_set_get_n_beam
   procedure :: get_n_in => particle_set_get_n_in
   procedure :: get_n_vir => particle_set_get_n_vir
   procedure :: get_n_out => particle_set_get_n_out
   procedure :: get_n_tot => particle_set_get_n_tot
   procedure :: get_n_remnants => particle_set_get_n_remnants
 <<Particles: procedures>>=
   function particle_set_get_n_beam (pset) result (n_beam)
      class(particle_set_t), intent(in) :: pset
      integer :: n_beam
      n_beam = pset%n_beam
   end function particle_set_get_n_beam
 
   function particle_set_get_n_in (pset) result (n_in)
      class(particle_set_t), intent(in) :: pset
      integer :: n_in
      n_in = pset%n_in
   end function particle_set_get_n_in
 
   function particle_set_get_n_vir (pset) result (n_vir)
      class(particle_set_t), intent(in) :: pset
      integer :: n_vir
      n_vir = pset%n_vir
    end function particle_set_get_n_vir
 
   function particle_set_get_n_out (pset) result (n_out)
      class(particle_set_t), intent(in) :: pset
      integer :: n_out
      n_out = pset%n_out
   end function particle_set_get_n_out
 
   function particle_set_get_n_tot (pset) result (n_tot)
      class(particle_set_t), intent(in) :: pset
      integer :: n_tot
      n_tot = pset%n_tot
   end function particle_set_get_n_tot
 
   function particle_set_get_n_remnants (pset) result (n_remn)
     class(particle_set_t), intent(in) :: pset
     integer :: n_remn
     if (allocated (pset%prt)) then
        n_remn = count (pset%prt%get_status () == PRT_BEAM_REMNANT)
     else
        n_remn = 0
     end if
   end function particle_set_get_n_remnants
 
 @ %def particle_set_get_n_beam
 @ %def particle_set_get_n_in
 @ %def particle_set_get_n_vir
 @ %def particle_set_get_n_out
 @ %def particle_set_get_n_tot
 @ %def particle_set_get_n_remnants
 @ Return a pointer to the particle corresponding to the number
 <<Particles: particle set: TBP>>=
   procedure :: get_particle => particle_set_get_particle
 <<Particles: procedures>>=
   function particle_set_get_particle (pset, index) result (particle)
     class(particle_set_t), intent(in) :: pset
     integer, intent(in) :: index
     type(particle_t) :: particle
     particle = pset%prt(index)
   end function particle_set_get_particle
 
 @ %def particle_set_get_particle
 @
 <<Particles: particle set: TBP>>=
   procedure :: get_indices => particle_set_get_indices
 <<Particles: procedures>>=
   pure function particle_set_get_indices (pset, mask) result (finals)
     integer, dimension(:), allocatable :: finals
     class(particle_set_t), intent(in) :: pset
     logical, dimension(:), intent(in) :: mask
     integer, dimension(size(mask)) :: indices
     integer :: i
     allocate (finals (count (mask)))
     indices = [(i, i=1, pset%n_tot)]
     finals = pack (indices, mask)
   end function particle_set_get_indices
 
 @ %def particle_set_get_indices
 @
 <<Particles: particle set: TBP>>=
   procedure :: get_in_and_out_momenta => particle_set_get_in_and_out_momenta
 <<Particles: procedures>>=
   function particle_set_get_in_and_out_momenta (pset) result (phs_point)
     type(phs_point_t) :: phs_point
     class(particle_set_t), intent(in) :: pset
     logical, dimension(:), allocatable :: mask
     integer, dimension(:), allocatable :: indices
     type(vector4_t), dimension(:), allocatable :: p
     allocate (mask (pset%get_n_tot ()))
     allocate (p (size (pset%prt)))
     mask = pset%prt%status == PRT_INCOMING .or. &
            pset%prt%status == PRT_OUTGOING
     allocate (indices (count (mask)))
     indices = pset%get_indices (mask)
     phs_point = pset%get_momenta (indices)
   end function particle_set_get_in_and_out_momenta
 
 @ %def particle_set_get_in_and_out_momenta
 @
 \subsubsection{Tools}
 Build a new particles array without hadronic remnants but with
 [[n_extra]] additional spots.  We also update the mother-daughter
 relations assuming the ordering [[b]], [[i]], [[r]], [[x]], [[o]].
 <<Particles: particle set: TBP>>=
   procedure :: without_hadronic_remnants => &
        particle_set_without_hadronic_remnants
 <<Particles: procedures>>=
   subroutine particle_set_without_hadronic_remnants &
          (particle_set, particles, n_particles, n_extra)
     class(particle_set_t), intent(inout) :: particle_set
     type(particle_t), dimension(:), allocatable, intent(out) :: particles
     integer, intent(out) :: n_particles
     integer, intent(in) :: n_extra
     logical, dimension(:), allocatable :: no_hadronic_remnants, &
          no_hadronic_children
     integer, dimension(:), allocatable :: children, new_children
     integer :: i, j, k, first_remnant
     first_remnant = particle_set%n_tot
     do i = 1, particle_set%n_tot
        if (particle_set%prt(i)%is_hadronic_beam_remnant ()) then
           first_remnant = i
           exit
        end if
     end do
     n_particles = count (.not. particle_set%prt%is_hadronic_beam_remnant ())
     allocate (no_hadronic_remnants (particle_set%n_tot))
     no_hadronic_remnants = .not. particle_set%prt%is_hadronic_beam_remnant ()
     allocate (particles (n_particles + n_extra))
     k = 1
     do i = 1, particle_set%n_tot
        if (no_hadronic_remnants(i)) then
           particles(k) = particle_set%prt(i)
           k = k + 1
        end if
     end do
     if (n_particles /= particle_set%n_tot) then
        do i = 1, n_particles
           select case (particles(i)%get_status ())
           case (PRT_BEAM)
              if (allocated (children))  deallocate (children)
              allocate (children (particles(i)%get_n_children ()))
              children = particles(i)%get_children ()
              if (allocated (no_hadronic_children)) &
                   deallocate (no_hadronic_children)
              allocate (no_hadronic_children (particles(i)%get_n_children ()))
              no_hadronic_children = .not. &
                   particle_set%prt(children)%is_hadronic_beam_remnant ()
              if (allocated (new_children))  deallocate (new_children)
              allocate (new_children (count (no_hadronic_children)))
              new_children = pack (children, no_hadronic_children)
              call particles(i)%set_children (new_children)
           case (PRT_INCOMING, PRT_RESONANT)
              <<update children after remnant>>
           case (PRT_OUTGOING, PRT_BEAM_REMNANT)
           case default
           end select
        end do
     end if
   end subroutine particle_set_without_hadronic_remnants
 
 @ %def particle_set_without_hadronic_remnants
 <<update children after remnant>>=
 if (allocated (children))  deallocate (children)
 allocate (children (particles(i)%get_n_children ()))
 children = particles(i)%get_children ()
 do j = 1, size (children)
    if (children(j) > first_remnant) then
       children(j) = children (j) - &
            (particle_set%n_tot - n_particles)
    end if
 end do
 call particles(i)%set_children (children)
 @
 Build a new particles array without remnants but with
 [[n_extra]] additional spots.  We also update the mother-daughter
 relations assuming the ordering [[b]], [[i]], [[r]], [[x]], [[o]].
 <<Particles: particle set: TBP>>=
   procedure :: without_remnants => particle_set_without_remnants
 <<Particles: procedures>>=
   subroutine particle_set_without_remnants &
          (particle_set, particles, n_particles, n_extra)
     class(particle_set_t), intent(inout) :: particle_set
     type(particle_t), dimension(:), allocatable, intent(out) :: particles
     integer, intent(in) :: n_extra
     integer, intent(out) :: n_particles
     logical, dimension(:), allocatable :: no_remnants, no_children
     integer, dimension(:), allocatable :: children, new_children
     integer :: i,j, k, first_remnant
     first_remnant = particle_set%n_tot
     do i = 1, particle_set%n_tot
        if (particle_set%prt(i)%is_beam_remnant ()) then
           first_remnant = i
           exit
        end if
     end do
     allocate (no_remnants (particle_set%n_tot))
     no_remnants = .not. (particle_set%prt%is_beam_remnant ())
     n_particles = count (no_remnants)
     allocate (particles (n_particles + n_extra))
     k = 1
     do i = 1, particle_set%n_tot
        if (no_remnants(i)) then
           particles(k) = particle_set%prt(i)
           k = k + 1
        end if
     end do
     if (n_particles /= particle_set%n_tot) then
        do i = 1, n_particles
           select case (particles(i)%get_status ())
           case (PRT_BEAM)
              if (allocated (children))  deallocate (children)
              allocate (children (particles(i)%get_n_children ()))
              children = particles(i)%get_children ()
              if (allocated (no_children))  deallocate (no_children)
              allocate (no_children (particles(i)%get_n_children ()))
              no_children = .not. (particle_set%prt(children)%is_beam_remnant ())
              if (allocated (new_children))  deallocate (new_children)
              allocate (new_children (count (no_children)))
              new_children = pack (children, no_children)
              call particles(i)%set_children (new_children)
           case (PRT_INCOMING, PRT_RESONANT)
              <<update children after remnant>>
           case (PRT_OUTGOING, PRT_BEAM_REMNANT)
           case default
           end select
        end do
     end if
   end subroutine particle_set_without_remnants
 
 @ %def particle_set_without_remnants
 @
 <<Particles: particle set: TBP>>=
   procedure :: find_particle => particle_set_find_particle
 <<Particles: procedures>>=
   pure function particle_set_find_particle &
          (particle_set, pdg, momentum, abs_smallness, rel_smallness) result (idx)
     integer :: idx
     class(particle_set_t), intent(in) :: particle_set
     integer, intent(in) :: pdg
     type(vector4_t), intent(in) :: momentum
     real(default), intent(in), optional :: abs_smallness, rel_smallness
     integer :: i, j
     logical, dimension(0:3) :: equals
     idx = 0
     do i = 1, size (particle_set%prt)
        if (particle_set%prt(i)%flv%get_pdg () == pdg) then
           !!! Workaround for gfortran 4.8.3 with overloaded elemental function
           do j = 0, 3
             equals(j) = nearly_equal (particle_set%prt(i)%p%p(j), momentum%p(j), &
                                    abs_smallness, rel_smallness)
           end do
           if (all (equals)) then
              idx = i
              return
           end if
        end if
     end do
   end function particle_set_find_particle
 
 @ %def particle_set_find_particle
 <<Particles: particle set: TBP>>=
   procedure :: reverse_find_particle => particle_set_reverse_find_particle
 <<Particles: procedures>>=
   pure function particle_set_reverse_find_particle &
          (particle_set, pdg, momentum, abs_smallness, rel_smallness) result (idx)
     integer :: idx
     class(particle_set_t), intent(in) :: particle_set
     integer, intent(in) :: pdg
     type(vector4_t), intent(in) :: momentum
     real(default), intent(in), optional :: abs_smallness, rel_smallness
     integer :: i
     idx = 0
     do i = size (particle_set%prt), 1, -1
        if (particle_set%prt(i)%flv%get_pdg () == pdg) then
           if (all (nearly_equal (particle_set%prt(i)%p%p, momentum%p, &
                abs_smallness, rel_smallness))) then
              idx = i
              return
           end if
        end if
     end do
   end function particle_set_reverse_find_particle
 
 @ %def particle_set_reverse_find_particle
 @ This connects broken links of the form
 $\text{something} \to i \to \text{none or} j$ and
 $\text{none} \to j \to \text{something or none}$ where the particles $i$ and $j$
 are \emph{identical}.  It also works if $i \to j$, directly, and thus
 removes duplicates.  We are removing $j$ and connect the possible
 daughters to $i$.
 <<Particles: particle set: TBP>>=
   procedure :: remove_duplicates => particle_set_remove_duplicates
 <<Particles: procedures>>=
   subroutine particle_set_remove_duplicates (particle_set, smallness)
     class(particle_set_t), intent(inout) :: particle_set
     real(default), intent(in) :: smallness
     integer :: n_removals
     integer, dimension(particle_set%n_tot) :: to_remove
     type(particle_t), dimension(:), allocatable :: particles
     type(vector4_t) :: p_i
     integer, dimension(:), allocatable :: map
     to_remove = 0
     call find_duplicates ()
     n_removals = count (to_remove > 0)
     if (n_removals > 0) then
        call strip_duplicates (particles)
        call particle_set%replace (particles)
     end if
 
   contains
 
   <<Particles: remove duplicates: procedures>>
 
   end subroutine particle_set_remove_duplicates
 
 @ %def particle_set_remove_duplicates
 @ This doesn't catch all cases. Missing are splittings of the type
 $i \to \text{something and} j$.
 <<Particles: remove duplicates: procedures>>=
   subroutine find_duplicates ()
     integer :: pdg_i, child_i, i, j
     OUTER: do i = 1, particle_set%n_tot
        if (particle_set%prt(i)%status == PRT_OUTGOING .or. &
             particle_set%prt(i)%status == PRT_VIRTUAL .or. &
             particle_set%prt(i)%status == PRT_RESONANT) then
           if (allocated (particle_set%prt(i)%child)) then
              if (size (particle_set%prt(i)%child) > 1) cycle OUTER
              if (size (particle_set%prt(i)%child) == 1) then
                 child_i = particle_set%prt(i)%child(1)
              else
                 child_i = 0
              end if
           else
              child_i = 0
           end if
           pdg_i = particle_set%prt(i)%flv%get_pdg ()
           p_i = particle_set%prt(i)%p
           do j = i + 1, particle_set%n_tot
              if (pdg_i == particle_set%prt(j)%flv%get_pdg ()) then
                 if (all (nearly_equal (particle_set%prt(j)%p%p, p_i%p, &
                      abs_smallness = smallness, &
                      rel_smallness = 1E4_default * smallness))) then
                    if (child_i == 0 .or. j == child_i) then
                       to_remove(j) = i
                       call msg_debug2 (D_PARTICLES, &
                            "Particles: Will remove duplicate of i", i)
                       call msg_debug2 (D_PARTICLES, &
                            "Particles: j", j)
                    end if
                    cycle OUTER
                 end if
              end if
           end do
        end if
     end do OUTER
   end subroutine find_duplicates
 
 @
 <<Particles: remove duplicates: procedures>>=
   recursive function get_alive_index (try) result (alive)
     integer :: alive
     integer :: try
     if (map(try) > 0) then
        alive = map(try)
     else
        alive = get_alive_index (to_remove(try))
     end if
   end function get_alive_index
 
 @
 <<Particles: remove duplicates: procedures>>=
   subroutine strip_duplicates (particles)
     type(particle_t), dimension(:), allocatable, intent(out) :: particles
     integer :: kept, removed, i, j
     integer, dimension(:), allocatable :: old_children
     logical, dimension(:), allocatable :: parent_set
     call msg_debug (D_PARTICLES, "Particles: Removing duplicates")
     call msg_debug (D_PARTICLES, "Particles: n_removals", n_removals)
     if (debug2_active (D_PARTICLES)) then
        call msg_debug2 (D_PARTICLES, "Particles: Given set before removing:")
        call particle_set%write (summary=.true., compressed=.true.)
     end if
     allocate (particles (particle_set%n_tot - n_removals))
     allocate (map (particle_set%n_tot))
     allocate (parent_set (particle_set%n_tot))
     parent_set = .false.
     map = 0
     j = 0
     do i = 1, particle_set%n_tot
        if (to_remove(i) == 0) then
           j = j + 1
           map(i) = j
           call particles(j)%init (particle_set%prt(i))
        end if
     end do
     do i = 1, particle_set%n_tot
        if (map(i) /= 0) then
           if (.not. parent_set(map(i))) then
              call particles(map(i))%set_parents &
                   (map (particle_set%prt(i)%get_parents ()))
           end if
           call particles(map(i))%set_children &
                (map (particle_set%prt(i)%get_children ()))
        else
           removed = i
           kept = to_remove(i)
           if (particle_set%prt(removed)%has_children ()) then
              old_children = particle_set%prt(removed)%get_children ()
              do j = 1, size (old_children)
                 if (map(old_children(j)) > 0) then
                    call particles(map(old_children(j)))%set_parents &
                         ([get_alive_index (kept)])
                    parent_set(map(old_children(j))) = .true.
                    call particles(get_alive_index (kept))%add_child &
                         (map(old_children(j)))
                 end if
              end do
              particles(get_alive_index (kept))%status = PRT_RESONANT
           else
              particles(get_alive_index (kept))%status = PRT_OUTGOING
           end if
        end if
     end do
   end subroutine strip_duplicates
 
 @ Given a subevent, reset status codes.  If the new status is beam,
 incoming, or outgoing, we also make sure that the stored $p^2$ value
 is equal to the on-shell mass squared.
 <<Particles: particle set: TBP>>=
   procedure :: reset_status => particle_set_reset_status
 <<Particles: procedures>>=
   subroutine particle_set_reset_status (particle_set, index, status)
     class(particle_set_t), intent(inout) :: particle_set
     integer, dimension(:), intent(in) :: index
     integer, intent(in) :: status
     integer :: i
     if (allocated (particle_set%prt)) then
        do i = 1, size (index)
           call particle_set%prt(index(i))%reset_status (status)
        end do
     end if
     particle_set%n_beam  = &
          count (particle_set%prt%get_status () == PRT_BEAM)
     particle_set%n_in  = &
          count (particle_set%prt%get_status () == PRT_INCOMING)
     particle_set%n_out = &
          count (particle_set%prt%get_status () == PRT_OUTGOING)
     particle_set%n_vir = particle_set%n_tot &
          - particle_set%n_beam - particle_set%n_in - particle_set%n_out
   end subroutine particle_set_reset_status
 
 @ %def particle_set_reset_status
 @ Reduce a particle set to the essential entries.  The entries kept
 are those with status [[INCOMING]], [[OUTGOING]] or
 [[RESONANT]]. [[BEAM]] is kept if [[keep_beams]] is true. Other
 entries are skipped. The correlated state matrix, if any, is also
 ignored.
 <<Particles: particle set: TBP>>=
   procedure :: reduce => particle_set_reduce
 <<Particles: procedures>>=
   subroutine particle_set_reduce (pset_in, pset_out, keep_beams)
     class(particle_set_t), intent(in) :: pset_in
     type(particle_set_t), intent(out) :: pset_out
     logical, intent(in), optional :: keep_beams
     integer, dimension(:), allocatable :: status, map
     integer :: i, j
     logical :: kb
     kb = .false.;  if (present (keep_beams))  kb = keep_beams
     allocate (status (pset_in%n_tot))
     pset_out%factorization_mode = pset_in%factorization_mode
     status = pset_in%prt%get_status ()
     if (kb)  pset_out%n_beam  = count (status == PRT_BEAM)
     pset_out%n_in  = count (status == PRT_INCOMING)
     pset_out%n_vir = count (status == PRT_RESONANT)
     pset_out%n_out = count (status == PRT_OUTGOING)
     pset_out%n_tot = &
          pset_out%n_beam + pset_out%n_in + pset_out%n_vir + pset_out%n_out
     allocate (pset_out%prt (pset_out%n_tot))
     allocate (map (pset_in%n_tot))
     map = 0
     j = 0
     if (kb) call copy_particles (PRT_BEAM)
     call copy_particles (PRT_INCOMING)
     call copy_particles (PRT_RESONANT)
     call copy_particles (PRT_OUTGOING)
     do i = 1, pset_in%n_tot
        if (map(i) == 0)  cycle
        !!! !!! triggers nagfor bug!
        !!!  call particle_set_parents (pset_out%prt(map(i)), &
        !!!       map (particle_set_get_real_parents (pset_in, i)))
        !!!  call particle_set_children (pset_out%prt(map(i)), &
        !!!       map (particle_set_get_real_children (pset_in, i)))
        !!! !!! workaround:
        call pset_out%prt(map(i))%set_parents &
             (pset_in%get_real_parents (i, kb))
        call pset_out%prt(map(i))%set_parents &
             (map (pset_out%prt(map(i))%parent))
        call pset_out%prt(map(i))%set_children &
             (pset_in%get_real_children (i, kb))
        call pset_out%prt(map(i))%set_children &
             (map (pset_out%prt(map(i))%child))
     end do
   contains
     subroutine copy_particles (stat)
       integer, intent(in) :: stat
       integer :: i
       do i = 1, pset_in%n_tot
          if (status(i) == stat) then
             j = j + 1
             map(i) = j
             call particle_init_particle (pset_out%prt(j), pset_in%prt(i))
          end if
       end do
     end subroutine copy_particles
   end subroutine particle_set_reduce
 
 @ %def particles_set_reduce
 @ Remove the beam particles and beam remnants from the particle set if the
 keep beams flag is false. If keep beams is not given, the beam particles
 and the beam remnants are removed.
 The correlated state matrix, if any, is also ignored.
 <<Particles: particle set: TBP>>=
   procedure :: filter_particles => particle_set_filter_particles
 <<Particles: procedures>>=
   subroutine particle_set_filter_particles &
        (pset_in, pset_out, keep_beams, real_parents, keep_virtuals)
     class(particle_set_t), intent(in) :: pset_in
     type(particle_set_t), intent(out) :: pset_out
     logical, intent(in), optional :: keep_beams, real_parents, keep_virtuals
     integer, dimension(:), allocatable :: status, map
     logical, dimension(:), allocatable :: filter
     integer :: i, j
     logical :: kb, rp, kv
     kb = .false.;  if (present (keep_beams))  kb = keep_beams
     rp = .false.; if (present (real_parents)) rp = real_parents
     kv = .true.; if (present (keep_virtuals)) kv = keep_virtuals
     call msg_debug (D_PARTICLES, "filter_particles")
     if (debug2_active (D_PARTICLES)) then
        print *, 'keep_beams =    ', kb
        print *, 'real_parents =    ', rp
        print *, 'keep_virtuals =    ', kv
        print *, '>>> pset_in : '
        call pset_in%write(compressed=.true.)
     end if
     call count_and_allocate()
     map = 0
     j = 0
     filter = .false.
     if (.not. kb) filter = status == PRT_BEAM .or. status == PRT_BEAM_REMNANT
     if (.not. kv) filter = filter .or. status == PRT_VIRTUAL
     call copy_particles ()
     do i = 1, pset_in%n_tot
        if (map(i) == 0)  cycle
        if (rp) then
           call pset_out%prt(map(i))%set_parents &
                (map (pset_in%get_real_parents (i, kb)))
           call pset_out%prt(map(i))%set_children &
                (map (pset_in%get_real_children (i, kb)))
        else
           call pset_out%prt(map(i))%set_parents &
                (map (pset_in%prt(i)%get_parents ()))
           call pset_out%prt(map(i))%set_children &
                (map (pset_in%prt(i)%get_children ()))
        end if
     end do
     if (debug2_active (D_PARTICLES)) then
        print *, '>>> pset_out : '
        call pset_out%write(compressed=.true.)
     end if
   contains
     <<filter particles: procedures>>
   end subroutine particle_set_filter_particles
 
 @ %def particles_set_filter_particles
 <<filter particles: procedures>>=
     subroutine copy_particles ()
       integer :: i
       do i = 1, pset_in%n_tot
          if (.not. filter(i)) then
             j = j + 1
             map(i) = j
             call particle_init_particle (pset_out%prt(j), pset_in%prt(i))
          end if
       end do
     end subroutine copy_particles
 
 <<filter particles: procedures>>=
   subroutine count_and_allocate
     allocate (status (pset_in%n_tot))
     status = particle_get_status (pset_in%prt)
     if (kb)  pset_out%n_beam  = count (status == PRT_BEAM)
     pset_out%n_in  = count (status == PRT_INCOMING)
     if (kb .and. kv) then
        pset_out%n_vir = count (status == PRT_VIRTUAL) + &
             count (status == PRT_RESONANT) + &
             count (status == PRT_BEAM_REMNANT)
     else if (kb .and. .not. kv) then
        pset_out%n_vir = count (status == PRT_RESONANT) + &
             count (status == PRT_BEAM_REMNANT)
     else if (.not. kb .and. kv) then
        pset_out%n_vir = count (status == PRT_VIRTUAL) + &
             count (status == PRT_RESONANT)
     else
        pset_out%n_vir = count (status == PRT_RESONANT)
     end if
     pset_out%n_out = count (status == PRT_OUTGOING)
     pset_out%n_tot = &
          pset_out%n_beam + pset_out%n_in + pset_out%n_vir + pset_out%n_out
     allocate (pset_out%prt (pset_out%n_tot))
     allocate (map (pset_in%n_tot))
     allocate (filter (pset_in%n_tot))
   end subroutine count_and_allocate
 
 @ Transform a particle set into HEPEVT-compatible form.  In this form, for each
 particle, the parents and the children are contiguous in the particle array.
 Usually, this requires to clone some particles.
 
 We do not know in advance how many particles the canonical form will have.
 To be on the safe side, allocate four times the original size.
 <<Particles: particle set: TBP>>=
   procedure :: to_hepevt_form => particle_set_to_hepevt_form
 <<Particles: procedures>>=
   subroutine particle_set_to_hepevt_form (pset_in, pset_out)
     class(particle_set_t), intent(in) :: pset_in
     type(particle_set_t), intent(out) :: pset_out
     type :: particle_entry_t
        integer :: src = 0
        integer :: status = 0
        integer :: orig = 0
        integer :: copy = 0
     end type particle_entry_t
     type(particle_entry_t), dimension(:), allocatable :: prt
     integer, dimension(:), allocatable :: map1, map2
     integer, dimension(:), allocatable :: parent, child
     integer :: n_tot, n_parents, n_children, i, j, c, n
 
     n_tot = pset_in%n_tot
     allocate (prt (4 * n_tot))
     allocate (map1(4 * n_tot))
     allocate (map2(4 * n_tot))
     map1 = 0
     map2 = 0
     allocate (child (n_tot))
     allocate (parent (n_tot))
     n = 0
     do i = 1, n_tot
        if (pset_in%prt(i)%get_n_parents () == 0) then
           call append (i)
        end if
     end do
     do i = 1, n_tot
        n_children = pset_in%prt(i)%get_n_children ()
        if (n_children > 0) then
           child(1:n_children) = pset_in%prt(i)%get_children ()
           c = child(1)
           if (map1(c) == 0) then
              n_parents = pset_in%prt(c)%get_n_parents ()
              if (n_parents > 1) then
                 parent(1:n_parents) = pset_in%prt(c)%get_parents ()
                 if (i == parent(1) .and. &
                     any( [(map1(i)+j-1, j=1,n_parents)] /= &
                            map1(parent(1:n_parents)))) then
                    do j = 1, n_parents
                       call append (parent(j))
                    end do
                 end if
              else if (map1(i) == 0) then
                 call append (i)
              end if
              do j = 1, n_children
                 call append (child(j))
              end do
           end if
        else if (map1(i) == 0) then
           call append (i)
        end if
     end do
     do i = n, 1, -1
        if (prt(i)%status /= PRT_OUTGOING) then
           do j = 1, i-1
              if (prt(j)%status == PRT_OUTGOING) then
                 call append(prt(j)%src)
              end if
           end do
           exit
        end if
     end do
     pset_out%n_beam = count (prt(1:n)%status == PRT_BEAM)
     pset_out%n_in   = count (prt(1:n)%status == PRT_INCOMING)
     pset_out%n_vir  = count (prt(1:n)%status == PRT_RESONANT)
     pset_out%n_out  = count (prt(1:n)%status == PRT_OUTGOING)
     pset_out%n_tot = n
     allocate (pset_out%prt (n))
     do i = 1, n
        call particle_init_particle (pset_out%prt(i), pset_in%prt(prt(i)%src))
        call pset_out%prt(i)%reset_status (prt(i)%status)
        if (prt(i)%orig == 0) then
           call pset_out%prt(i)%set_parents &
                (map2 (pset_in%prt(prt(i)%src)%get_parents ()))
        else
           call pset_out%prt(i)%set_parents ([ prt(i)%orig ])
        end if
        if (prt(i)%copy == 0) then
           call pset_out%prt(i)%set_children &
                (map1 (pset_in%prt(prt(i)%src)%get_children ()))
        else
           call pset_out%prt(i)%set_children ([ prt(i)%copy ])
        end if
     end do
   contains
     subroutine append (i)
       integer, intent(in) :: i
       n = n + 1
       if (n > size (prt)) &
            call msg_bug ("Particle set transform to HEPEVT: insufficient space")
       prt(n)%src = i
       prt(n)%status = pset_in%prt(i)%get_status ()
       if (map1(i) == 0) then
          map1(i) = n
       else
          prt(map2(i))%status = PRT_VIRTUAL
          prt(map2(i))%copy = n
          prt(n)%orig = map2(i)
       end if
       map2(i) = n
     end subroutine append
   end subroutine particle_set_to_hepevt_form
 
 @ %def particle_set_to_hepevt_form
 @ This procedure aims at reconstructing the momenta of an interaction,
 given a particle set.  Since the particle orderings
 <<Particles: particle set: TBP>>=
   procedure :: fill_interaction => particle_set_fill_interaction
 <<Particles: procedures>>=
   subroutine particle_set_fill_interaction &
        (pset, int, n_in, recover_beams, check_match, state_flv)
     class(particle_set_t), intent(in) :: pset
     type(interaction_t), intent(inout) :: int
     integer, intent(in) :: n_in
     logical, intent(in), optional :: recover_beams, check_match
     type(state_flv_content_t), intent(in), optional :: state_flv
     integer, dimension(:), allocatable :: map, pdg
     integer, dimension(:), allocatable :: i_in, i_out, p_in, p_out
     logical, dimension(:), allocatable :: i_set
     integer :: n_out, i, p
     logical :: r_beams, check
     r_beams = .false.;  if (present (recover_beams))  r_beams = recover_beams
     check = .true.;  if (present (check_match))  check = check_match
     if (check) then
        call find_hard_process_in_int  (i_in, i_out)
        call find_hard_process_in_pset (p_in, p_out)
        n_out = size (i_out)
        if (size (i_in) /= n_in)  call err_int_n_in
        if (size (p_in) /= n_in)  call err_pset_n_in
        if (size (p_out) /= n_out)  call err_pset_n_out
        call extract_hard_process_from_pset (pdg)
        call determine_map_for_hard_process (map, state_flv)
        if (.not. r_beams) then
           select case (n_in)
           case (1)
              call recover_parents (p_in(1), map)
           case (2)
              do i = 1, 2
                 call recover_parents (p_in(i), map)
              end do
              do p = 1, 2
                 call recover_radiation (p, map)
              end do
           end select
        end if
     else
        allocate (map (int%get_n_tot ()))
        map = [(i, i = 1, size (map))]
        r_beams = .false.
     end if
     allocate (i_set (int%get_n_tot ()), source = .false.)
     do p = 1, size (map)
        if (map(p) /= 0) then
           i_set(map(p)) = .true.
           call int%set_momentum &
                (pset%prt(p)%get_momentum (), map(p))
        end if
     end do
     if (r_beams) then
        do i = 1, n_in
           call reconstruct_beam_and_radiation (i, i_set)
        end do
     end if
     if (any (.not. i_set))  call err_map
   contains
     subroutine find_hard_process_in_pset (p_in, p_out)
       integer, dimension(:), allocatable, intent(out) :: p_in, p_out
       integer, dimension(:), allocatable :: p_status, p_idx
       integer :: n_out_p
       integer :: i
       allocate (p_status (pset%n_tot), p_idx (pset%n_tot))
       p_status = pset%prt%get_status ()
       p_idx = [(i, i = 1, pset%n_tot)]
       allocate (p_in (n_in))
       p_in = pack (p_idx, p_status == PRT_INCOMING)
       if (size (p_in) == 0)  call err_pset_hard
       i = p_in(1)
       n_out_p = particle_get_n_children (pset%prt(i))
       allocate (p_out (n_out_p))
       p_out = particle_get_children (pset%prt(i))
     end subroutine find_hard_process_in_pset
     subroutine find_hard_process_in_int (i_in, i_out)
       integer, dimension(:), allocatable, intent(out) :: i_in, i_out
       integer :: n_in_i
       integer :: i
       i = int%get_n_tot ()
       n_in_i = interaction_get_n_parents (int, i)
       if (n_in_i /= n_in)  call err_int_n_in
       allocate (i_in (n_in))
       i_in = interaction_get_parents (int, i)
       i = i_in(1)
       n_out = interaction_get_n_children (int, i)
       allocate (i_out (n_out))
       i_out = interaction_get_children (int, i)
     end subroutine find_hard_process_in_int
     subroutine extract_hard_process_from_pset (pdg)
       integer, dimension(:), allocatable, intent(out) :: pdg
       integer, dimension(:), allocatable :: pdg_p
       logical, dimension(:), allocatable :: mask_p
       integer :: i
       allocate (pdg_p (pset%n_tot))
       pdg_p = pset%prt%get_pdg ()
       allocate (mask_p (pset%n_tot), source = .false.)
       mask_p (p_in) = .true.
       mask_p (p_out) = .true.
       allocate (pdg (n_in + n_out))
       pdg = pack (pdg_p, mask_p)
     end subroutine extract_hard_process_from_pset
     subroutine determine_map_for_hard_process (map, state_flv)
       integer, dimension(:), allocatable, intent(out) :: map
       type(state_flv_content_t), intent(in), optional :: state_flv
       integer, dimension(:), allocatable :: pdg_i, map_i
       integer :: n_tot
       logical, dimension(:), allocatable :: mask_i, mask_p
       logical :: success
       n_tot = int%get_n_tot ()
       if (present (state_flv)) then
          allocate (mask_i (n_tot), source = .false.)
          mask_i (i_in) = .true.
          mask_i (i_out) = .true.
          allocate (pdg_i (n_tot), map_i (n_tot))
          pdg_i = unpack (pdg, mask_i, 0)
          call state_flv%match (pdg_i, success, map_i)
          allocate (mask_p (pset%n_tot), source = .false.)
          mask_p (p_in) = .true.
          mask_p (p_out) = .true.
          allocate (map (size (mask_p)), &
               source = unpack (pack (map_i, mask_i), mask_p, 0))
          if (.not. success)  call err_mismatch
       else
          allocate (map (n_tot), source = 0)
          map(p_in) = i_in
          map(p_out) = i_out
       end if
     end subroutine determine_map_for_hard_process
     recursive subroutine recover_parents (p, map)
       integer, intent(in) :: p
       integer, dimension(:), intent(inout) :: map
       integer :: i, n, n_p, q, k
       integer, dimension(:), allocatable :: i_parents, p_parents
       integer, dimension(1) :: pp
       i = map(p)
       n = interaction_get_n_parents (int, i)
       q = p
       n_p = particle_get_n_parents (pset%prt(q))
       do while (n_p == 1)
          pp = particle_get_parents (pset%prt(q))
          if (pset%prt(pp(1))%get_n_children () > 1)  exit
          q = pp(1)
          n_p = pset%prt(q)%get_n_parents ()
       end do
       if (n_p /= n)  call err_map
       allocate (i_parents (n), p_parents (n))
       i_parents = interaction_get_parents (int, i)
       p_parents = pset%prt(q)%get_parents ()
       do k = 1, n
          q = p_parents(k)
          if (map(q) == 0) then
             map(q) = i_parents(k)
             call recover_parents (q, map)
          end if
       end do
     end subroutine recover_parents
     recursive subroutine recover_radiation (p, map)
       integer, intent(in) :: p
       integer, dimension(:), intent(inout) :: map
       integer :: i, n, n_p, q, k
       integer, dimension(:), allocatable :: i_children, p_children
       if (particle_get_status (pset%prt(p)) == PRT_INCOMING)  return
       i = map(p)
       n = interaction_get_n_children (int, i)
       n_p = pset%prt(p)%get_n_children ()
       if (n_p /= n)  call err_map
       allocate (i_children (n), p_children (n))
       i_children = interaction_get_children (int, i)
       p_children = pset%prt(p)%get_children ()
       do k = 1, n
          q = p_children(k)
          if (map(q) == 0) then
             i = i_children(k)
             if (interaction_get_n_children (int, i) == 0) then
                map(q) = i
             else
                select case (n)
                case (2)
                   select case (k)
                   case (1);  map(q) = i_children(2)
                   case (2);  map(q) = i_children(1)
                   end select
                case (4)
                   select case (k)
                   case (1);  map(q) = i_children(3)
                   case (2);  map(q) = i_children(4)
                   case (3);  map(q) = i_children(1)
                   case (4);  map(q) = i_children(2)
                   end select
                case default
                   call err_radiation
                end select
             end if
          else
             call recover_radiation (q, map)
          end if
       end do
     end subroutine recover_radiation
     subroutine reconstruct_beam_and_radiation (k, i_set)
       integer, intent(in) :: k
       logical, dimension(:), intent(inout) :: i_set
       integer :: k_src, k_in, k_rad
       type(interaction_t), pointer :: int_src
       integer, dimension(2) :: i_child
       call int%find_source (k, int_src, k_src)
       call int%set_momentum (int_src%get_momentum (k_src), k)
       i_set(k) = .true.
       if (n_in == 2) then
          i_child = interaction_get_children (int, k)
          if (interaction_get_n_children (int, i_child(1)) > 0) then
             k_in = i_child(1);  k_rad = i_child(2)
          else
             k_in = i_child(2);  k_rad = i_child(1)
          end if
          if (.not. i_set(k_in))  call err_beams
          call int%set_momentum &
               (int%get_momentum (k) - int%get_momentum (k_in), k_rad)
          i_set(k_rad) = .true.
       end if
     end subroutine reconstruct_beam_and_radiation
     subroutine err_pset_hard
       call msg_fatal ("Reading particle set: no particles marked as incoming")
     end subroutine err_pset_hard
     subroutine err_int_n_in
       integer :: n
       if (allocated (i_in)) then
          n = size (i_in)
       else
          n = 0
       end if
       write (msg_buffer, "(A,I0,A,I0)") &
            "Filling hard process from particle set: expect ", n_in, &
            " incoming particle(s), found ", n
       call msg_bug
     end subroutine err_int_n_in
     subroutine err_pset_n_in
       write (msg_buffer, "(A,I0,A,I0)") &
            "Reading hard-process particle set: should contain ", n_in, &
            " incoming particle(s), found ", size (p_in)
       call msg_fatal
     end subroutine err_pset_n_in
     subroutine err_pset_n_out
       write (msg_buffer, "(A,I0,A,I0)") &
            "Reading hard-process particle set: should contain ", n_out, &
            " outgoing particle(s), found ", size (p_out)
       call msg_fatal
     end subroutine err_pset_n_out
     subroutine err_mismatch
       call pset%write ()
       call state_flv%write ()
       call msg_fatal ("Reading particle set: Flavor combination " &
            // "does not match requested process")
     end subroutine err_mismatch
     subroutine err_map
       call pset%write ()
       call int%basic_write ()
       call msg_fatal ("Reading hard-process particle set: " &
            // "Incomplete mapping from particle set to interaction")
     end subroutine err_map
     subroutine err_beams
       call pset%write ()
       call int%basic_write ()
       call msg_fatal ("Reading particle set: Beam structure " &
            // "does not match requested process")
     end subroutine err_beams
     subroutine err_radiation
       call int%basic_write ()
       call msg_bug ("Reading particle set: Interaction " &
            // "contains inconsistent radiation pattern.")
     end subroutine err_radiation
   end subroutine particle_set_fill_interaction
 
 @ %def particle_set_fill_interaction
 @
 This procedure reconstructs an array of vertex indices from the
 parent-child information in the particle entries, according to the
 HepMC scheme.  For each particle, we determine which vertex it comes
 from and which vertex it goes to.  We return the two arrays and the
 maximum vertex index.
 
 For each particle in the list, we first check its parents.  If for any
 parent the vertex where it goes to is already known, this vertex index
 is assigned as the current 'from' vertex.  Otherwise, a new index is
 created, assigned as the current 'from' vertex, and as the 'to' vertex
 for all parents.
 
 Then, the analogous procedure is done for the children.
 
 Furthermore, we assign to each vertex the vertex position from the
 parent(s). We check that these vertex positions coincide, and if not
 return a null vector.
 <<Particles: particle set: TBP>>=
   procedure :: assign_vertices => particle_set_assign_vertices
 <<Particles: procedures>>=
   subroutine particle_set_assign_vertices &
        (particle_set, v_from, v_to, n_vertices)
     class(particle_set_t), intent(in) :: particle_set
     integer, dimension(:), intent(out) :: v_from, v_to
     integer, intent(out) :: n_vertices
     integer, dimension(:), allocatable :: parent, child
     integer :: n_parents, n_children, vf, vt
     integer :: i, j, v
     v_from = 0
     v_to = 0
     vf = 0
     vt = 0
     do i = 1, particle_set%n_tot
        n_parents = particle_set%prt(i)%get_n_parents ()
        if (n_parents /= 0) then
           allocate (parent (n_parents))
           parent = particle_set%prt(i)%get_parents ()
           SCAN_PARENTS: do j = 1, size (parent)
              v = v_to(parent(j))
              if (v /= 0) then
                 v_from(i) = v;  exit SCAN_PARENTS
              end if
           end do SCAN_PARENTS
           if (v_from(i) == 0) then
              vf = vf + 1;  v_from(i) = vf
              v_to(parent) = vf
           end if
           deallocate (parent)
        end if
        n_children = particle_set%prt(i)%get_n_children ()
        if (n_children /= 0) then
           allocate (child (n_children))
           child = particle_set%prt(i)%get_children ()
           SCAN_CHILDREN: do j = 1, size (child)
              v = v_from(child(j))
              if (v /= 0) then
                 v_to(i) = v;  exit SCAN_CHILDREN
              end if
           end do SCAN_CHILDREN
           if (v_to(i) == 0) then
              vt = vt + 1;  v_to(i) = vt
              v_from(child) = vt
           end if
           deallocate (child)
        end if
     end do
     n_vertices = max (vf, vt)
   end subroutine particle_set_assign_vertices
 
 @ %def particle_set_assign_vertices
 @
 \subsection{Expression interface}
 This converts a [[particle_set]] object as defined here to a more
 concise [[subevt]] object that can be used as the event root of an
 expression.  In particular, the latter lacks virtual particles, spin
 correlations and parent-child relations.
 
 We keep beam particles, incoming partons, and outgoing partons.
 Furthermore, we keep radiated particles (a.k.a.\ beam remnants) if
 they have no children in the current particle set, and mark them as
 outgoing particles.
+
+If [[colorize]] is set and true, mark all particles in the subevent as
+colorized, and set color/anticolor flow indices where they are defined.
+Colorless particles do not get indices but are still marked as colorized, for
+consistency.
 <<Particles: particle set: TBP>>=
   procedure :: to_subevt => particle_set_to_subevt
 <<Particles: procedures>>=
-  subroutine particle_set_to_subevt (particle_set, subevt)
+  subroutine particle_set_to_subevt (particle_set, subevt, colorize)
     class(particle_set_t), intent(in) :: particle_set
     type(subevt_t), intent(out) :: subevt
+    logical, intent(in), optional :: colorize
     integer :: n_tot, n_beam, n_in, n_out, n_rad
     integer :: i, k, n_active
     integer, dimension(2) :: hel
     logical :: keep
     n_tot  = particle_set_get_n_tot      (particle_set)
     n_beam = particle_set_get_n_beam     (particle_set)
     n_in   = particle_set_get_n_in       (particle_set)
     n_out  = particle_set_get_n_out      (particle_set)
     n_rad  = particle_set_get_n_remnants (particle_set)
     call subevt_init (subevt, n_beam + n_rad + n_in + n_out)
     k = 0
     do i = 1, n_tot
        associate (prt => particle_set%prt(i))
          keep = .false.
          select case (particle_get_status (prt))
          case (PRT_BEAM)
             k = k + 1
             call subevt_set_beam (subevt, k, &
                  particle_get_pdg (prt), &
                  particle_get_momentum (prt), &
                  particle_get_p2 (prt))
             keep = .true.
          case (PRT_INCOMING)
             k = k + 1
             call subevt_set_incoming (subevt, k, &
                  particle_get_pdg (prt), &
                  particle_get_momentum (prt), &
                  particle_get_p2 (prt))
             keep = .true.
          case (PRT_OUTGOING)
             k = k + 1
             call subevt_set_outgoing (subevt, k, &
                  particle_get_pdg (prt), &
                  particle_get_momentum (prt), &
                  particle_get_p2 (prt))
             keep = .true.
          case (PRT_BEAM_REMNANT)
             if (particle_get_n_children (prt) == 0) then
                k = k + 1
                call subevt_set_outgoing (subevt, k, &
                     particle_get_pdg (prt), &
                     particle_get_momentum (prt), &
                     particle_get_p2 (prt))
                keep = .true.
             end if
          end select
          if (keep) then
             if (prt%polarization == PRT_DEFINITE_HELICITY) then
                if (prt%hel%is_diagonal ()) then
                   hel = prt%hel%to_pair ()
                   call subevt_polarize (subevt, k, hel(1))
                end if
             end if
          end if
+         if (present (colorize)) then
+            if (colorize) then
+               call subevt_colorize &
+                    (subevt, i, prt%col%get_col (), prt%col%get_acl ())
+            end if
+         end if
        end associate
        n_active = k
     end do
     call subevt_reset (subevt, n_active)
   end subroutine particle_set_to_subevt
 
 @ %def particle_set_to_subevt
 @
 This replaces the [[particle\_set\%prt array]] with a given array of particles
 <<Particles: particle set: TBP>>=
   procedure :: replace => particle_set_replace
 <<Particles: procedures>>=
   subroutine particle_set_replace (particle_set, newprt)
     class(particle_set_t), intent(inout) :: particle_set
     type(particle_t), intent(in), dimension(:), allocatable :: newprt
     if (allocated (particle_set%prt))  deallocate (particle_set%prt)
     allocate (particle_set%prt(size (newprt)))
     particle_set%prt = newprt
     particle_set%n_tot = size (newprt)
     particle_set%n_beam = count (particle_get_status (newprt) == PRT_BEAM)
     particle_set%n_in = count (particle_get_status (newprt) == PRT_INCOMING)
     particle_set%n_out = count (particle_get_status (newprt) == PRT_OUTGOING)
     particle_set%n_vir = particle_set%n_tot &
          - particle_set%n_beam - particle_set%n_in - particle_set%n_out
   end subroutine particle_set_replace
 
 @ %def particle_set_replace
 @ This routines orders the outgoing particles into clusters of
 colorless particles and such of particles ordered corresponding to the
 indices of the color lines. All outgoing particles in the ordered set
 appear as child of the corresponding outgoing particle in the
 unordered set, including colored beam remnants. We always start
 continue via the anti-color line, such that color flows within each
 Lund string system is always continued from the anticolor of one
 particle to the identical color index of another particle.
 <<Particles: particle set: TBP>>=
   procedure :: order_color_lines => particle_set_order_color_lines
 <<Particles: procedures>>=
   subroutine particle_set_order_color_lines (pset_out, pset_in)
     class(particle_set_t), intent(inout) :: pset_out
     type(particle_set_t), intent(in) :: pset_in
     integer :: i, n, n_col_rem
     n_col_rem = 0
     do i = 1, pset_in%n_tot
        if (pset_in%prt(i)%get_status () == PRT_BEAM_REMNANT .and. &
             any (pset_in%prt(i)%get_color () /= 0)) then
           n_col_rem = n_col_rem + 1
        end if
     end do
     pset_out%n_beam = pset_in%n_beam
     pset_out%n_in   = pset_in%n_in
     pset_out%n_vir  = pset_in%n_vir + pset_in%n_out + n_col_rem
     pset_out%n_out  = pset_in%n_out
     pset_out%n_tot  = pset_in%n_tot + pset_in%n_out + n_col_rem
     pset_out%correlated_state = pset_in%correlated_state
     pset_out%factorization_mode = pset_in%factorization_mode
     allocate (pset_out%prt (pset_out%n_tot))
     do i = 1, pset_in%n_tot
        call pset_out%prt(i)%init (pset_in%prt(i))
        call pset_out%prt(i)%set_children (pset_in%prt(i)%child)
        call pset_out%prt(i)%set_parents (pset_in%prt(i)%parent)
     end do
     n = pset_in%n_tot
     do i = 1, pset_in%n_tot
        if (pset_out%prt(i)%get_status () == PRT_OUTGOING .and. &
            all (pset_out%prt(i)%get_color () == 0) .and. &
            .not. pset_out%prt(i)%has_children ()) then
           n = n + 1
           call pset_out%prt(n)%init (pset_out%prt(i))
           call pset_out%prt(i)%reset_status (PRT_VIRTUAL)
           call pset_out%prt(i)%add_child (n)
           call pset_out%prt(i)%set_parents ([i])
        end if
     end do
     if (n_col_rem > 0) then
        do i = 1, n_col_rem
        end do
     end if
   end subroutine particle_set_order_color_lines
 
 @ %def particle_set_order_color_lines
 @
 Eliminate numerical noise
 <<Particles: public>>=
   public :: pacify
 <<Particles: interfaces>>=
   interface pacify
      module procedure pacify_particle
      module procedure pacify_particle_set
   end interface pacify
 
 <<Particles: procedures>>=
   subroutine pacify_particle (prt)
     class(particle_t), intent(inout) :: prt
     real(default) :: e
     e = epsilon (1._default) * energy (prt%p)
     call pacify (prt%p, 10 * e)
     call pacify (prt%p2, 1e4 * e)
   end subroutine pacify_particle
 
   subroutine pacify_particle_set (pset)
     class(particle_set_t), intent(inout) :: pset
     integer :: i
     do i = 1, pset%n_tot
        call pacify (pset%prt(i))
     end do
   end subroutine pacify_particle_set
 
 @ %def pacify
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[particles_ut.f90]]>>=
 <<File header>>
 
 module particles_ut
   use unit_tests
   use particles_uti
 
 <<Standard module head>>
 
 <<Particles: public test>>
 
 contains
 
 <<Particles: test driver>>
 
 end module particles_ut
 @ %def particles_ut
 @
 <<[[particles_uti.f90]]>>=
 <<File header>>
 
 module particles_uti
 
 <<Use kinds>>
   use io_units
   use numeric_utils
   use constants, only: one, tiny_07
   use lorentz
   use flavors
   use colors
   use helicities
   use quantum_numbers
   use state_matrices
   use interactions
   use evaluators
   use model_data
   use subevents
 
   use particles
 
 <<Standard module head>>
 
 <<Particles: test declarations>>
 
 contains
 
 <<Particles: tests>>
 
 <<Particles: test auxiliary>>
 
 end module particles_uti
 @ %def particles_ut
 @ API: driver for the unit tests below.
 <<Particles: public test>>=
   public :: particles_test
 <<Particles: test driver>>=
   subroutine particles_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Particles: execute tests>>
   end subroutine particles_test
 
 @ %def particles_test
 @
 Check the basic setup of the [[particle_set_t]] type:
 Set up a chain of production and decay and factorize the result into
 particles.  The process is $d\bar d \to Z \to q\bar q$.
 <<Particles: execute tests>>=
   call test (particles_1, "particles_1", &
        "check particle_set routines", &
        u, results)
 <<Particles: test declarations>>=
   public :: particles_1
 <<Particles: tests>>=
   subroutine particles_1 (u)
     use os_interface
     integer, intent(in) :: u
     type(model_data_t), target :: model
     type(flavor_t), dimension(3) :: flv
     type(color_t), dimension(3) :: col
     type(helicity_t), dimension(3) :: hel
     type(quantum_numbers_t), dimension(3) :: qn
     type(vector4_t), dimension(3) :: p
     type(interaction_t), target :: int1, int2
     type(quantum_numbers_mask_t) :: qn_mask_conn
     type(evaluator_t), target :: eval
     type(interaction_t) :: int
     type(particle_set_t) :: particle_set1, particle_set2
     type(particle_set_t) :: particle_set3, particle_set4
     type(subevt_t) :: subevt
     logical :: ok
     integer :: unit, iostat
 
     write (u, "(A)")  "* Test output: Particles"
     write (u, "(A)")  "*   Purpose: test particle_set routines"
     write (u, "(A)")
 
     write (u, "(A)")  "* Reading model file"
 
     call model%init_sm_test ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Initializing production process"
 
     call int1%basic_init (2, 0, 1, set_relations=.true.)
     call flv%init ([1, -1, 23], model)
     call col%init_col_acl ([0, 0, 0], [0, 0, 0])
     call hel(3)%init (1, 1)
     call qn%init (flv, col, hel)
     call int1%add_state (qn, value=(0.25_default, 0._default))
     call hel(3)%init (1,-1)
     call qn%init (flv, col, hel)
     call int1%add_state (qn, value=(0._default, 0.25_default))
     call hel(3)%init (-1, 1)
     call qn%init (flv, col, hel)
     call int1%add_state (qn, value=(0._default,-0.25_default))
     call hel(3)%init (-1,-1)
     call qn%init (flv, col, hel)
     call int1%add_state (qn, value=(0.25_default, 0._default))
     call hel(3)%init (0, 0)
     call qn%init (flv, col, hel)
     call int1%add_state (qn, value=(0.5_default, 0._default))
     call int1%freeze ()
     p(1) = vector4_moving (45._default, 45._default, 3)
     p(2) = vector4_moving (45._default,-45._default, 3)
     p(3) = p(1) + p(2)
     call int1%set_momenta (p)
 
     write (u, "(A)")
     write (u, "(A)")  "* Setup decay process"
 
     call int2%basic_init (1, 0, 2, set_relations=.true.)
     call flv%init ([23, 1, -1], model)
     call col%init_col_acl ([0, 501, 0], [0, 0, 501])
     call hel%init ([1, 1, 1], [1, 1, 1])
     call qn%init (flv, col, hel)
     call int2%add_state (qn, value=(1._default, 0._default))
     call hel%init ([1, 1, 1], [-1,-1,-1])
     call qn%init (flv, col, hel)
     call int2%add_state (qn, value=(0._default, 0.1_default))
     call hel%init ([-1,-1,-1], [1, 1, 1])
     call qn%init (flv, col, hel)
     call int2%add_state (qn, value=(0._default,-0.1_default))
     call hel%init ([-1,-1,-1], [-1,-1,-1])
     call qn%init (flv, col, hel)
     call int2%add_state (qn, value=(1._default, 0._default))
     call hel%init ([0, 1,-1], [0, 1,-1])
     call qn%init (flv, col, hel)
     call int2%add_state (qn, value=(4._default, 0._default))
     call hel%init ([0,-1, 1], [0, 1,-1])
     call qn%init (flv, col, hel)
     call int2%add_state (qn, value=(2._default, 0._default))
     call hel%init ([0, 1,-1], [0,-1, 1])
     call qn%init (flv, col, hel)
     call int2%add_state (qn, value=(2._default, 0._default))
     call hel%init ([0,-1, 1], [0,-1, 1])
     call qn%init (flv, col, hel)
     call int2%add_state (qn, value=(4._default, 0._default))
     call flv%init ([23, 2, -2], model)
     call hel%init ([0, 1,-1], [0, 1,-1])
     call qn%init (flv, col, hel)
     call int2%add_state (qn, value=(0.5_default, 0._default))
     call hel%init ([0,-1, 1], [0,-1, 1])
     call qn%init (flv, col, hel)
     call int2%add_state (qn, value=(0.5_default, 0._default))
     call int2%freeze ()
     p(2) = vector4_moving (45._default, 45._default, 2)
     p(3) = vector4_moving (45._default,-45._default, 2)
     call int2%set_momenta (p)
     call int2%set_source_link (1, int1, 3)
     call int1%basic_write (u)
     call int2%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Concatenate production and decay"
 
     call eval%init_product (int1, int2, qn_mask_conn, &
          connections_are_resonant=.true.)
     call eval%receive_momenta ()
     call eval%evaluate ()
     call eval%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Factorize as subevent (complete, polarized)"
     write (u, "(A)")
 
     int = eval%interaction_t
     call particle_set1%init &
          (ok, int, int, FM_FACTOR_HELICITY, &
           [0.2_default, 0.2_default], .false., .true.)
     call particle_set1%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Factorize as subevent (in/out only, selected helicity)"
     write (u, "(A)")
 
     int = eval%interaction_t
     call particle_set2%init &
          (ok, int, int, FM_SELECT_HELICITY, &
           [0.9_default, 0.9_default], .false., .false.)
     call particle_set2%write (u)
     call particle_set2%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Factorize as subevent (complete, selected helicity)"
     write (u, "(A)")
 
     int = eval%interaction_t
     call particle_set2%init &
          (ok, int, int, FM_SELECT_HELICITY, &
           [0.7_default, 0.7_default], .false., .true.)
     call particle_set2%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  &
          "* Factorize (complete, polarized, correlated); write and read again"
     write (u, "(A)")
 
     int = eval%interaction_t
     call particle_set3%init &
          (ok, int, int, FM_FACTOR_HELICITY, &
           [0.7_default, 0.7_default], .true., .true.)
     call particle_set3%write (u)
 
     unit = free_unit ()
     open (unit, action="readwrite", form="unformatted", status="scratch")
     call particle_set3%write_raw (unit)
     rewind (unit)
     call particle_set4%read_raw (unit, iostat=iostat)
     call particle_set4%set_model (model)
     close (unit)
 
     write (u, "(A)")
     write (u, "(A)")  "* Result from reading"
     write (u, "(A)")
 
     call particle_set4%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Transform to a subevt object"
     write (u, "(A)")
 
     call particle_set4%to_subevt (subevt)
     call subevt_write (subevt, u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call particle_set1%final ()
     call particle_set2%final ()
     call particle_set3%final ()
     call particle_set4%final ()
     call eval%final ()
     call int1%final ()
     call int2%final ()
 
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: particles_1"
 
   end subroutine particles_1
 
 @ %def particles_1
 @
 Reconstruct a hard interaction from a particle set.
 <<Particles: execute tests>>=
   call test (particles_2, "particles_2", &
        "reconstruct hard interaction", &
        u, results)
 <<Particles: test declarations>>=
   public :: particles_2
 <<Particles: tests>>=
   subroutine particles_2 (u)
 
     integer, intent(in) :: u
     type(interaction_t) :: int
     type(state_flv_content_t) :: state_flv
     type(particle_set_t) :: pset
     type(flavor_t), dimension(:), allocatable :: flv
     type(quantum_numbers_t), dimension(:), allocatable :: qn
     integer :: i, j
 
     write (u, "(A)")  "* Test output: Particles"
     write (u, "(A)")  "*   Purpose: reconstruct simple interaction"
     write (u, "(A)")
 
     write (u, "(A)")  "* Set up a 2 -> 3 interaction"
     write (u, "(A)")  "    + incoming partons marked as virtual"
     write (u, "(A)")  "    + no quantum numbers"
     write (u, "(A)")
 
     call reset_interaction_counter ()
     call int%basic_init (0, 2, 3)
     do i = 1, 2
        do j = 3, 5
           call int%relate (i, j)
        end do
     end do
 
     allocate (qn (5))
     call int%add_state (qn)
     call int%freeze ()
 
     call int%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually set up a flavor-content record"
     write (u, "(A)")
 
     call state_flv%init (1, &
          mask = [.false., .false., .true., .true., .true.])
     call state_flv%set_entry (1, &
          pdg = [11, 12, 3, 4, 5], &
          map = [1, 2, 3, 4, 5])
 
     call state_flv%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually create a matching particle set"
     write (u, "(A)")
 
     pset%n_beam = 0
     pset%n_in   = 2
     pset%n_vir  = 0
     pset%n_out  = 3
     pset%n_tot  = 5
     allocate (pset%prt (pset%n_tot))
     do i = 1, 2
        call pset%prt(i)%reset_status (PRT_INCOMING)
        call pset%prt(i)%set_children ([3,4,5])
     end do
     do i = 3, 5
        call pset%prt(i)%reset_status (PRT_OUTGOING)
        call pset%prt(i)%set_parents ([1,2])
     end do
     call pset%prt(1)%set_momentum (vector4_at_rest (1._default))
     call pset%prt(2)%set_momentum (vector4_at_rest (2._default))
     call pset%prt(3)%set_momentum (vector4_at_rest (5._default))
     call pset%prt(4)%set_momentum (vector4_at_rest (4._default))
     call pset%prt(5)%set_momentum (vector4_at_rest (3._default))
 
     allocate (flv (5))
     call flv%init ([11,12,5,4,3])
     do i = 1, 5
        call pset%prt(i)%set_flavor (flv(i))
     end do
 
     call pset%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "*   Fill interaction from particle set"
     write (u, "(A)")
 
     call pset%fill_interaction (int, 2, state_flv=state_flv)
     call int%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call int%final ()
     call pset%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: particles_2"
 
   end subroutine particles_2
 
 @ %def particles_2
 @
 Reconstruct an interaction with beam structure, e.g., a hadronic
 interaction, from a particle set.
 <<Particles: execute tests>>=
   call test (particles_3, "particles_3", &
        "reconstruct interaction with beam structure", &
        u, results)
 <<Particles: test declarations>>=
   public :: particles_3
 <<Particles: tests>>=
   subroutine particles_3 (u)
 
     integer, intent(in) :: u
     type(interaction_t) :: int
     type(state_flv_content_t) :: state_flv
     type(particle_set_t) :: pset
     type(quantum_numbers_t), dimension(:), allocatable :: qn
     integer :: i, j
 
     write (u, "(A)")  "* Test output: Particles"
     write (u, "(A)")  "*   Purpose: reconstruct simple interaction"
     write (u, "(A)")
 
     write (u, "(A)")  "* Set up a 2 -> 2 -> 3 interaction with radiation"
     write (u, "(A)")  "    + no quantum numbers"
     write (u, "(A)")
 
     call reset_interaction_counter ()
     call int%basic_init (0, 6, 3)
     call int%relate (1, 3)
     call int%relate (1, 4)
     call int%relate (2, 5)
     call int%relate (2, 6)
     do i = 4, 6, 2
        do j = 7, 9
           call int%relate (i, j)
        end do
     end do
 
     allocate (qn (9))
     call int%add_state (qn)
     call int%freeze ()
 
     call int%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually set up a flavor-content record"
     write (u, "(A)")
 
     call state_flv%init (1, &
          mask = [.false., .false., .false., .false., .false., .false., &
          .true., .true., .true.])
     call state_flv%set_entry (1, &
          pdg = [2011, 2012, 91, 11, 92, 12, 3, 4, 5], &
          map = [1, 2, 3, 4, 5, 6, 7, 8, 9])
 
     call state_flv%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually create a matching particle set"
     write (u, "(A)")
 
     call create_test_particle_set_1 (pset)
 
     call pset%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "*   Fill interaction from particle set"
     write (u, "(A)")
 
     call pset%fill_interaction (int, 2, state_flv=state_flv)
     call int%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call int%final ()
     call pset%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: particles_3"
 
   end subroutine particles_3
 
 @ %def particles_3
 @
 <<Particles: test auxiliary>>=
   subroutine create_test_particle_set_1 (pset)
     type(particle_set_t), intent(out) :: pset
     type(flavor_t), dimension(:), allocatable :: flv
     integer :: i
     pset%n_beam = 2
     pset%n_in   = 2
     pset%n_vir  = 2
     pset%n_out  = 3
     pset%n_tot  = 9
 
     allocate (pset%prt (pset%n_tot))
     call pset%prt(1)%reset_status (PRT_BEAM)
     call pset%prt(2)%reset_status (PRT_BEAM)
     call pset%prt(3)%reset_status (PRT_INCOMING)
     call pset%prt(4)%reset_status (PRT_INCOMING)
     call pset%prt(5)%reset_status (PRT_BEAM_REMNANT)
     call pset%prt(6)%reset_status (PRT_BEAM_REMNANT)
     call pset%prt(7)%reset_status (PRT_OUTGOING)
     call pset%prt(8)%reset_status (PRT_OUTGOING)
     call pset%prt(9)%reset_status (PRT_OUTGOING)
 
     call pset%prt(1)%set_children ([3,5])
     call pset%prt(2)%set_children ([4,6])
     call pset%prt(3)%set_children ([7,8,9])
     call pset%prt(4)%set_children ([7,8,9])
 
     call pset%prt(3)%set_parents ([1])
     call pset%prt(4)%set_parents ([2])
     call pset%prt(5)%set_parents ([1])
     call pset%prt(6)%set_parents ([2])
     call pset%prt(7)%set_parents ([3,4])
     call pset%prt(8)%set_parents ([3,4])
     call pset%prt(9)%set_parents ([3,4])
 
     call pset%prt(1)%set_momentum (vector4_at_rest (1._default))
     call pset%prt(2)%set_momentum (vector4_at_rest (2._default))
     call pset%prt(3)%set_momentum (vector4_at_rest (4._default))
     call pset%prt(4)%set_momentum (vector4_at_rest (6._default))
     call pset%prt(5)%set_momentum (vector4_at_rest (3._default))
     call pset%prt(6)%set_momentum (vector4_at_rest (5._default))
     call pset%prt(7)%set_momentum (vector4_at_rest (7._default))
     call pset%prt(8)%set_momentum (vector4_at_rest (8._default))
     call pset%prt(9)%set_momentum (vector4_at_rest (9._default))
 
     allocate (flv (9))
     call flv%init ([2011, 2012, 11, 12, 91, 92, 3, 4, 5])
     do i = 1, 9
        call pset%prt(i)%set_flavor (flv(i))
     end do
   end subroutine create_test_particle_set_1
 
 @ %def create_test_particle_set_1
 
 @
 Reconstruct an interaction with beam structure, e.g., a hadronic
 interaction, from a particle set that is missing the beam information.
 <<Particles: execute tests>>=
   call test (particles_4, "particles_4", &
        "reconstruct interaction with missing beams", &
        u, results)
 <<Particles: test declarations>>=
   public :: particles_4
 <<Particles: tests>>=
   subroutine particles_4 (u)
 
     integer, intent(in) :: u
     type(interaction_t) :: int
     type(interaction_t), target :: int_beams
     type(state_flv_content_t) :: state_flv
     type(particle_set_t) :: pset
     type(flavor_t), dimension(:), allocatable :: flv
     type(quantum_numbers_t), dimension(:), allocatable :: qn
     integer :: i, j
 
     write (u, "(A)")  "* Test output: Particles"
     write (u, "(A)")  "*   Purpose: reconstruct beams"
     write (u, "(A)")
 
     call reset_interaction_counter ()
 
     write (u, "(A)")  "* Set up an interaction that contains beams only"
     write (u, "(A)")
 
     call int_beams%basic_init (0, 0, 2)
     call int_beams%set_momentum (vector4_at_rest (1._default), 1)
     call int_beams%set_momentum (vector4_at_rest (2._default), 2)
     allocate (qn (2))
     call int_beams%add_state (qn)
     call int_beams%freeze ()
 
     call int_beams%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Set up a 2 -> 2 -> 3 interaction with radiation"
     write (u, "(A)")  "    + no quantum numbers"
     write (u, "(A)")
 
     call int%basic_init (0, 6, 3)
     call int%relate (1, 3)
     call int%relate (1, 4)
     call int%relate (2, 5)
     call int%relate (2, 6)
     do i = 4, 6, 2
        do j = 7, 9
           call int%relate (i, j)
        end do
     end do
     do i = 1, 2
        call int%set_source_link (i, int_beams, i)
     end do
 
     deallocate (qn)
     allocate (qn (9))
     call int%add_state (qn)
     call int%freeze ()
 
     call int%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually set up a flavor-content record"
     write (u, "(A)")
 
     call state_flv%init (1, &
          mask = [.false., .false., .false., .false., .false., .false., &
          .true., .true., .true.])
     call state_flv%set_entry (1, &
          pdg = [2011, 2012, 91, 11, 92, 12, 3, 4, 5], &
          map = [1, 2, 3, 4, 5, 6, 7, 8, 9])
 
     call state_flv%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually create a matching particle set"
     write (u, "(A)")
 
     pset%n_beam = 0
     pset%n_in   = 2
     pset%n_vir  = 0
     pset%n_out  = 3
     pset%n_tot  = 5
 
     allocate (pset%prt (pset%n_tot))
     call pset%prt(1)%reset_status (PRT_INCOMING)
     call pset%prt(2)%reset_status (PRT_INCOMING)
     call pset%prt(3)%reset_status (PRT_OUTGOING)
     call pset%prt(4)%reset_status (PRT_OUTGOING)
     call pset%prt(5)%reset_status (PRT_OUTGOING)
 
     call pset%prt(1)%set_children ([3,4,5])
     call pset%prt(2)%set_children ([3,4,5])
 
     call pset%prt(3)%set_parents ([1,2])
     call pset%prt(4)%set_parents ([1,2])
     call pset%prt(5)%set_parents ([1,2])
 
     call pset%prt(1)%set_momentum (vector4_at_rest (6._default))
     call pset%prt(2)%set_momentum (vector4_at_rest (6._default))
     call pset%prt(3)%set_momentum (vector4_at_rest (3._default))
     call pset%prt(4)%set_momentum (vector4_at_rest (4._default))
     call pset%prt(5)%set_momentum (vector4_at_rest (5._default))
 
     allocate (flv (5))
     call flv%init ([11, 12, 3, 4, 5])
     do i = 1, 5
        call pset%prt(i)%set_flavor (flv(i))
     end do
 
     call pset%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "*   Fill interaction from particle set"
     write (u, "(A)")
 
     call pset%fill_interaction (int, 2, state_flv=state_flv, &
          recover_beams = .true.)
     call int%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call int%final ()
     call pset%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: particles_4"
 
   end subroutine particles_4
 
 @ %def particles_4
 @
 Reconstruct an interaction with beam structure and cloned particles
 (radiated particles repeated in the event record, to maintain some
 canonical ordering).
 <<Particles: execute tests>>=
   call test (particles_5, "particles_5", &
        "reconstruct interaction with beams and duplicate entries", &
        u, results)
 <<Particles: test declarations>>=
   public :: particles_5
 <<Particles: tests>>=
   subroutine particles_5 (u)
 
     integer, intent(in) :: u
     type(interaction_t) :: int
     type(state_flv_content_t) :: state_flv
     type(particle_set_t) :: pset
     type(flavor_t), dimension(:), allocatable :: flv
     type(quantum_numbers_t), dimension(:), allocatable :: qn
     integer :: i, j
 
     write (u, "(A)")  "* Test output: Particles"
     write (u, "(A)")  "*   Purpose: reconstruct event with duplicate entries"
     write (u, "(A)")
 
     write (u, "(A)")  "* Set up a 2 -> 2 -> 3 interaction with radiation"
     write (u, "(A)")  "    + no quantum numbers"
     write (u, "(A)")
 
     call reset_interaction_counter ()
     call int%basic_init (0, 6, 3)
     call int%relate (1, 3)
     call int%relate (1, 4)
     call int%relate (2, 5)
     call int%relate (2, 6)
     do i = 4, 6, 2
        do j = 7, 9
           call int%relate (i, j)
        end do
     end do
 
     allocate (qn (9))
     call int%add_state (qn)
     call int%freeze ()
 
     call int%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually set up a flavor-content record"
     write (u, "(A)")
 
     call state_flv%init (1, &
          mask = [.false., .false., .false., .false., .false., .false., &
          .true., .true., .true.])
     call state_flv%set_entry (1, &
          pdg = [2011, 2012, 91, 11, 92, 12, 3, 4, 5], &
          map = [1, 2, 3, 4, 5, 6, 7, 8, 9])
 
     call state_flv%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually create a matching particle set"
     write (u, "(A)")
 
     pset%n_beam = 2
     pset%n_in   = 2
     pset%n_vir  = 4
     pset%n_out  = 5
     pset%n_tot  = 13
 
     allocate (pset%prt (pset%n_tot))
     call pset%prt(1)%reset_status (PRT_BEAM)
     call pset%prt(2)%reset_status (PRT_BEAM)
     call pset%prt(3)%reset_status (PRT_VIRTUAL)
     call pset%prt(4)%reset_status (PRT_VIRTUAL)
     call pset%prt(5)%reset_status (PRT_VIRTUAL)
     call pset%prt(6)%reset_status (PRT_VIRTUAL)
     call pset%prt(7)%reset_status (PRT_INCOMING)
     call pset%prt(8)%reset_status (PRT_INCOMING)
     call pset%prt( 9)%reset_status (PRT_OUTGOING)
     call pset%prt(10)%reset_status (PRT_OUTGOING)
     call pset%prt(11)%reset_status (PRT_OUTGOING)
     call pset%prt(12)%reset_status (PRT_OUTGOING)
     call pset%prt(13)%reset_status (PRT_OUTGOING)
 
     call pset%prt(1)%set_children ([3,4])
     call pset%prt(2)%set_children ([5,6])
     call pset%prt(3)%set_children ([ 7])
     call pset%prt(4)%set_children ([ 9])
     call pset%prt(5)%set_children ([ 8])
     call pset%prt(6)%set_children ([10])
     call pset%prt(7)%set_children ([11,12,13])
     call pset%prt(8)%set_children ([11,12,13])
 
     call pset%prt(3)%set_parents ([1])
     call pset%prt(4)%set_parents ([1])
     call pset%prt(5)%set_parents ([2])
     call pset%prt(6)%set_parents ([2])
     call pset%prt( 7)%set_parents ([3])
     call pset%prt( 8)%set_parents ([5])
     call pset%prt( 9)%set_parents ([4])
     call pset%prt(10)%set_parents ([6])
     call pset%prt(11)%set_parents ([7,8])
     call pset%prt(12)%set_parents ([7,8])
     call pset%prt(13)%set_parents ([7,8])
 
     call pset%prt(1)%set_momentum (vector4_at_rest (1._default))
     call pset%prt(2)%set_momentum (vector4_at_rest (2._default))
     call pset%prt(3)%set_momentum (vector4_at_rest (4._default))
     call pset%prt(4)%set_momentum (vector4_at_rest (3._default))
     call pset%prt(5)%set_momentum (vector4_at_rest (6._default))
     call pset%prt(6)%set_momentum (vector4_at_rest (5._default))
     call pset%prt(7)%set_momentum (vector4_at_rest (4._default))
     call pset%prt(8)%set_momentum (vector4_at_rest (6._default))
     call pset%prt( 9)%set_momentum (vector4_at_rest (3._default))
     call pset%prt(10)%set_momentum (vector4_at_rest (5._default))
     call pset%prt(11)%set_momentum (vector4_at_rest (7._default))
     call pset%prt(12)%set_momentum (vector4_at_rest (8._default))
     call pset%prt(13)%set_momentum (vector4_at_rest (9._default))
 
     allocate (flv (13))
     call flv%init ([2011, 2012, 11, 91, 12, 92, 11, 12, 91, 92, 3, 4, 5])
     do i = 1, 13
        call pset%prt(i)%set_flavor (flv(i))
     end do
 
     call pset%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "*   Fill interaction from particle set"
     write (u, "(A)")
 
     call pset%fill_interaction (int, 2, state_flv=state_flv)
     call int%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call int%final ()
     call pset%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: particles_5"
 
   end subroutine particles_5
 
 @ %def particles_5
 @
 Reconstruct an interaction with pair spectrum, e.g., beamstrahlung from a
 particle set.
 <<Particles: execute tests>>=
   call test (particles_6, "particles_6", &
        "reconstruct interaction with pair spectrum", &
        u, results)
 <<Particles: test declarations>>=
   public :: particles_6
 <<Particles: tests>>=
   subroutine particles_6 (u)
 
     integer, intent(in) :: u
     type(interaction_t) :: int
     type(state_flv_content_t) :: state_flv
     type(particle_set_t) :: pset
     type(flavor_t), dimension(:), allocatable :: flv
     type(quantum_numbers_t), dimension(:), allocatable :: qn
     integer :: i, j
 
     write (u, "(A)")  "* Test output: Particles"
     write (u, "(A)")  "*   Purpose: reconstruct interaction with pair spectrum"
     write (u, "(A)")
 
     write (u, "(A)")  "* Set up a 2 -> 2 -> 3 interaction with radiation"
     write (u, "(A)")  "    + no quantum numbers"
     write (u, "(A)")
 
     call reset_interaction_counter ()
     call int%basic_init (0, 6, 3)
     do i = 1, 2
        do j = 3, 6
           call int%relate (i, j)
        end do
     end do
     do i = 5, 6
        do j = 7, 9
           call int%relate (i, j)
        end do
     end do
 
     allocate (qn (9))
     call int%add_state (qn)
     call int%freeze ()
 
     call int%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually set up a flavor-content record"
     write (u, "(A)")
 
     call state_flv%init (1, &
          mask = [.false., .false., .false., .false., .false., .false., &
          .true., .true., .true.])
     call state_flv%set_entry (1, &
          pdg = [1011, 1012, 21, 22, 11, 12, 3, 4, 5], &
          map = [1, 2, 3, 4, 5, 6, 7, 8, 9])
 
     call state_flv%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually create a matching particle set"
     write (u, "(A)")
 
     pset%n_beam = 2
     pset%n_in   = 2
     pset%n_vir  = 2
     pset%n_out  = 3
     pset%n_tot  = 9
 
     allocate (pset%prt (pset%n_tot))
     call pset%prt(1)%reset_status (PRT_BEAM)
     call pset%prt(2)%reset_status (PRT_BEAM)
     call pset%prt(3)%reset_status (PRT_INCOMING)
     call pset%prt(4)%reset_status (PRT_INCOMING)
     call pset%prt(5)%reset_status (PRT_OUTGOING)
     call pset%prt(6)%reset_status (PRT_OUTGOING)
     call pset%prt(7)%reset_status (PRT_OUTGOING)
     call pset%prt(8)%reset_status (PRT_OUTGOING)
     call pset%prt(9)%reset_status (PRT_OUTGOING)
 
     call pset%prt(1)%set_children ([3,4,5,6])
     call pset%prt(2)%set_children ([3,4,5,6])
     call pset%prt(3)%set_children ([7,8,9])
     call pset%prt(4)%set_children ([7,8,9])
 
     call pset%prt(3)%set_parents ([1,2])
     call pset%prt(4)%set_parents ([1,2])
     call pset%prt(5)%set_parents ([1,2])
     call pset%prt(6)%set_parents ([1,2])
     call pset%prt(7)%set_parents ([3,4])
     call pset%prt(8)%set_parents ([3,4])
     call pset%prt(9)%set_parents ([3,4])
 
     call pset%prt(1)%set_momentum (vector4_at_rest (1._default))
     call pset%prt(2)%set_momentum (vector4_at_rest (2._default))
     call pset%prt(3)%set_momentum (vector4_at_rest (5._default))
     call pset%prt(4)%set_momentum (vector4_at_rest (6._default))
     call pset%prt(5)%set_momentum (vector4_at_rest (3._default))
     call pset%prt(6)%set_momentum (vector4_at_rest (4._default))
     call pset%prt(7)%set_momentum (vector4_at_rest (7._default))
     call pset%prt(8)%set_momentum (vector4_at_rest (8._default))
     call pset%prt(9)%set_momentum (vector4_at_rest (9._default))
 
     allocate (flv (9))
     call flv%init ([1011, 1012, 11, 12, 21, 22, 3, 4, 5])
     do i = 1, 9
        call pset%prt(i)%set_flavor (flv(i))
     end do
 
     call pset%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "*   Fill interaction from particle set"
     write (u, "(A)")
 
     call pset%fill_interaction (int, 2, state_flv=state_flv)
     call int%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call int%final ()
     call pset%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: particles_6"
 
   end subroutine particles_6
 
 @ %def particles_6
 @
 Reconstruct a hard decay interaction from a shuffled particle set.
 <<Particles: execute tests>>=
   call test (particles_7, "particles_7", &
        "reconstruct decay interaction with reordering", &
        u, results)
 <<Particles: test declarations>>=
   public :: particles_7
 <<Particles: tests>>=
   subroutine particles_7 (u)
 
     integer, intent(in) :: u
     type(interaction_t) :: int
     type(state_flv_content_t) :: state_flv
     type(particle_set_t) :: pset
     type(flavor_t), dimension(:), allocatable :: flv
     type(quantum_numbers_t), dimension(:), allocatable :: qn
     integer :: i, j
 
     write (u, "(A)")  "* Test output: Particles"
     write (u, "(A)")  "*   Purpose: reconstruct decay interaction with reordering"
     write (u, "(A)")
 
     write (u, "(A)")  "* Set up a 1 -> 3 interaction"
     write (u, "(A)")  "    + no quantum numbers"
     write (u, "(A)")
 
     call reset_interaction_counter ()
     call int%basic_init (0, 1, 3)
     do j = 2, 4
        call int%relate (1, j)
     end do
 
     allocate (qn (4))
     call int%add_state (qn)
     call int%freeze ()
 
     call int%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually set up a flavor-content record"
     write (u, "(A)")  "*   assumed interaction: 6 12 5 -11"
     write (u, "(A)")
 
     call state_flv%init (1, &
          mask = [.false., .true., .true., .true.])
     call state_flv%set_entry (1, &
          pdg = [6, 5, -11, 12], &
          map = [1, 4, 2, 3])
 
     call state_flv%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually create a matching particle set"
     write (u, "(A)")
 
     pset%n_beam = 0
     pset%n_in   = 1
     pset%n_vir  = 0
     pset%n_out  = 3
     pset%n_tot  = 4
     allocate (pset%prt (pset%n_tot))
     do i = 1, 1
        call pset%prt(i)%reset_status (PRT_INCOMING)
        call pset%prt(i)%set_children ([2,3,4])
     end do
     do i = 2, 4
        call pset%prt(i)%reset_status (PRT_OUTGOING)
        call pset%prt(i)%set_parents ([1])
     end do
     call pset%prt(1)%set_momentum (vector4_at_rest (1._default))
     call pset%prt(2)%set_momentum (vector4_at_rest (3._default))
     call pset%prt(3)%set_momentum (vector4_at_rest (2._default))
     call pset%prt(4)%set_momentum (vector4_at_rest (4._default))
 
     allocate (flv (4))
     call flv%init ([6,5,12,-11])
     do i = 1, 4
        call pset%prt(i)%set_flavor (flv(i))
     end do
 
     call pset%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "*   Fill interaction from particle set"
     write (u, "(A)")
 
     call pset%fill_interaction (int, 1, state_flv=state_flv)
     call int%basic_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call int%final ()
     call pset%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: particles_7"
 
   end subroutine particles_7
 
 @ %def particles_7
 @
 <<Particles: execute tests>>=
   call test (particles_8, "particles_8", &
             "Test functions on particle sets", u, results)
 <<Particles: test declarations>>=
   public :: particles_8
 <<Particles: tests>>=
   subroutine particles_8 (u)
     integer, intent(in) :: u
     type(particle_set_t) :: particle_set
     type(particle_t), dimension(:), allocatable :: particles
     integer, allocatable, dimension(:) :: children, parents
     integer :: n_particles, i
     write (u, "(A)")  "* Test output: particles_8"
     write (u, "(A)")  "*   Purpose: Test functions on particle sets"
     write (u, "(A)")
 
     call create_test_particle_set_1 (particle_set)
     call particle_set%write (u)
     call assert_equal (u, particle_set%n_tot, 9)
     call assert_equal (u, particle_set%n_beam, 2)
     allocate (children (particle_set%prt(3)%get_n_children ()))
     children = particle_set%prt(3)%get_children()
     call assert_equal (u, particle_set%prt(children(1))%get_pdg (), 3)
     call assert_equal (u, size (particle_set%prt(1)%get_children ()), 2)
     call assert_equal (u, size (particle_set%prt(2)%get_children ()), 2)
 
     call particle_set%without_hadronic_remnants &
          (particles, n_particles, 3)
     call particle_set%replace (particles)
     write (u, "(A)")
     call particle_set%write (u)
 
     call assert_equal (u, n_particles, 7)
     call assert_equal (u, size(particles), 10)
     call assert_equal (u, particle_set%n_tot, 10)
     call assert_equal (u, particle_set%n_beam, 2)
     do i = 3, 4
        if (allocated (children))  deallocate (children)
        allocate (children (particle_set%prt(i)%get_n_children ()))
        children = particle_set%prt(i)%get_children()
        call assert_equal (u, particle_set%prt(children(1))%get_pdg (), 3)
        call assert_equal (u, particle_set%prt(children(2))%get_pdg (), 4)
        call assert_equal (u, particle_set%prt(children(3))%get_pdg (), 5)
     end do
     do i = 5, 7
        if (allocated (parents))  deallocate (parents)
        allocate (parents (particle_set%prt(i)%get_n_parents ()))
        parents = particle_set%prt(i)%get_parents()
        call assert_equal (u, particle_set%prt(parents(1))%get_pdg (), 11)
        call assert_equal (u, particle_set%prt(parents(2))%get_pdg (), 12)
     end do
     call assert_equal (u, size (particle_set%prt(1)%get_children ()), &
          1, "get children of 1")
     call assert_equal (u, size (particle_set%prt(2)%get_children ()), &
          1, "get children of 2")
 
     call assert_equal (u, particle_set%find_particle &
          (particle_set%prt(1)%get_pdg (), particle_set%prt(1)%p), &
          1, "find 1st particle")
     call assert_equal (u, particle_set%find_particle &
          (particle_set%prt(2)%get_pdg (), particle_set%prt(2)%p * &
           (one + tiny_07), rel_smallness=1.0E-6_default), &
          2, "find 2nd particle fuzzy")
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: particles_8"
   end subroutine particles_8
 
 @ %def particles_8
 @
 Order color lines into Lund string systems, without colored beam
 remnants first.
 <<Particles: execute tests>>=
   call test (particles_9, "particles_9", &
        "order into Lund strings, uncolored beam remnants", &
        u, results)
 <<Particles: test declarations>>=
   public :: particles_9
 <<Particles: tests>>=
   subroutine particles_9 (u)
     integer, intent(in) :: u
     write (u, "(A)")  "* Test output: particles_9"
     write (u, "(A)")  "*   Purpose: Order into Lund strings, "
     write (u, "(A)")  "*              uncolored beam remnants"
     write (u, "(A)")
   end subroutine particles_9
 
 @  %def particles_9
 
 
 
Index: trunk/src/transforms/transforms.nw
===================================================================
--- trunk/src/transforms/transforms.nw	(revision 8163)
+++ trunk/src/transforms/transforms.nw	(revision 8164)
@@ -1,13919 +1,13926 @@
 % -*- ess-noweb-default-code-mode: f90-mode; noweb-default-code-mode: f90-mode; -*-
 % WHIZARD event transforms and event API
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Event Implementation}
 \includemodulegraph{transforms}
 
 With a process object and the associated methods at hand, we can
 generate events for elementary processes and, by subsequent
 transformation, for complete physical processes.
 
 We have the following modules:
 \begin{description}
 \item[event\_transforms]
   Abstract base type for transforming a physical process with process
   instance and included evaluators, etc., into a new
   object.  The following modules extend this base type.
 \item[resonance\_insertion]
   Insert a resonance history into an event record, based on
   kinematical and matrix-element information.
 \item[recoil\_kinematics]
   Common kinematics routines for the ISR and EPA handlers.
 \item[isr\_photon\_handler]
   Transform collinear kinematics, as it results from applying ISR
   radiation, to non-collinear kinematics with a reasonable
   transverse-momentum distribution of the radiated photons, and also
   of the recoiling partonic event.
 \item[epa\_beam\_handler]
   For photon-initiated processes where the effective photon
   approximation is used in integration, to add in beam-particle
   recoil.  Analogous to the ISR handler.
 \item[decays]
   Combine the elementary process with elementary decay processes and
   thus transform the elementary event into a decayed event, still at
   the parton level.
 \item[showers]
   Create QED/QCD showers out of the partons that are emitted by
   elementary processes.  This should be interleaved with showering of
   radiated particles (structure functions) and multiple interactions.
 \item[hadrons]
   (not implemented yet) Apply hadronization to the partonic events,
   interleaved with hadron decays.  (The current setup relies on
   hadronizing partonic events externally.)
 \item[tau\_decays]
   (not implemented yet) Let $\tau$ leptons decay taking full spin
   correlations into account.
 \item[evt\_nlo]
   Handler for fixed-order NLO events.
 \item[events]
   Combine all pieces to generate full events.
 \item[eio\_raw]
   Raw I/O for complete events.
 \end{description}
 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Abstract Event Transforms}
 <<[[event_transforms.f90]]>>=
 <<File header>>
 
 module event_transforms
 
 <<Use kinds>>
 <<Use strings>>
   use io_units
   use format_utils, only: write_separator
   use diagnostics
   use model_data
   use interactions
   use particles
   use subevents
   use rng_base
   use quantum_numbers, only: quantum_numbers_t
   use process, only: process_t
   use instances, only: process_instance_t
   use process_stacks
 
 <<Standard module head>>
 
 <<Event transforms: public>>
 
 <<Event transforms: types>>
 
 <<Event transforms: interfaces>>
 
 contains
 
 <<Event transforms: procedures>>
 
 end module event_transforms
 
 @ %def event_transforms
 @
 \subsection{Abstract base type}
 Essentially, all methods are abstract, but some get minimal base
 versions.  We know that there will be a random-number generator at top
 level, and that we will relate to an elementary process.
 
 The model is stored separately.  It may contain modified setting that differ
 from the model instance stored in the process object.
 
 Each event transform contains a particle set that it can fill for
 further use.  There is a flag that indicates this.
 
 We will collect event transforms in a list, therefore we include
 [[previous]] and [[next]] pointers.
 <<Event transforms: public>>=
   public :: evt_t
 <<Event transforms: types>>=
   type, abstract :: evt_t
      type(process_t), pointer :: process => null ()
      type(process_instance_t), pointer :: process_instance => null ()
      class(model_data_t), pointer :: model => null ()
      class(rng_t), allocatable :: rng
      integer :: rejection_count = 0
      logical :: particle_set_exists = .false.
      type(particle_set_t) :: particle_set
      class(evt_t), pointer :: previous => null ()
      class(evt_t), pointer :: next => null ()
      real(default) :: weight = 0._default
      logical :: only_weighted_events = .false.
    contains
    <<Event transforms: evt: TBP>>
   end type evt_t
 
 @ %def evt_t
 @ Finalizer.  In any case, we finalize the r.n.g.  The process
 instance is a pointer and should not be finalized here.
 <<Event transforms: evt: TBP>>=
   procedure :: final => evt_final
   procedure :: base_final => evt_final
 <<Event transforms: procedures>>=
   subroutine evt_final (evt)
     class(evt_t), intent(inout) :: evt
     if (allocated (evt%rng))  call evt%rng%final ()
     if (evt%particle_set_exists) &
          call evt%particle_set%final ()
   end subroutine evt_final
 
 @ %def evt_final
 @ Print out the type of the [[evt]].
 <<Event transforms: evt: TBP>>=
   procedure (evt_write_name), deferred :: write_name
 <<Event transforms: interfaces>>=
   abstract interface
      subroutine evt_write_name (evt, unit)
        import
        class(evt_t), intent(in) :: evt
        integer, intent(in), optional :: unit
      end subroutine evt_write_name
   end interface
 
 @ %def evt_write_name
 @
 <<Event transforms: evt: TBP>>=
   procedure (evt_write), deferred :: write
 <<Event transforms: interfaces>>=
   abstract interface
      subroutine evt_write (evt, unit, verbose, more_verbose, testflag)
        import
        class(evt_t), intent(in) :: evt
        integer, intent(in), optional :: unit
        logical, intent(in), optional :: verbose, more_verbose, testflag
      end subroutine evt_write
   end interface
 
 @ %def evt_write
 @ Output.  We can print r.n.g. info.
 <<Event transforms: evt: TBP>>=
   procedure :: base_write => evt_base_write
 <<Event transforms: procedures>>=
   subroutine evt_base_write (evt, unit, testflag, show_set)
     class(evt_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: testflag, show_set
     integer :: u
     logical :: show
     u = given_output_unit (unit)
     show = .true.;  if (present (show_set))  show = show_set
     if (associated (evt%process)) then
        write (u, "(3x,A,A,A)")   "Associated process: '", &
             char (evt%process%get_id ()), "'"
     end if
     if (allocated (evt%rng)) then
        call evt%rng%write (u, 1)
        write (u, "(3x,A,I0)")  "Number of tries = ", evt%rejection_count
     end if
     if (show) then
        if (evt%particle_set_exists) then
           call write_separator (u)
           call evt%particle_set%write (u, testflag = testflag)
        end if
     end if
   end subroutine evt_base_write
 
 @ %def evt_base_write
 @ Connect the transform with a process instance (and thus with the
 associated process).  Use this to allocate the master random-number
 generator.
 
 This is not an initializer; we may initialize the transform by
 implementation-specific methods.
 <<Event transforms: evt: TBP>>=
   procedure :: connect => evt_connect
   procedure :: base_connect => evt_connect
 <<Event transforms: procedures>>=
   subroutine evt_connect (evt, process_instance, model, process_stack)
     class(evt_t), intent(inout), target :: evt
     type(process_instance_t), intent(in), target :: process_instance
     class(model_data_t), intent(in), target :: model
     type(process_stack_t), intent(in), optional :: process_stack
     evt%process => process_instance%process
     evt%process_instance => process_instance
     evt%model => model
     call evt%process%make_rng (evt%rng)
   end subroutine evt_connect
 
 @ %def evt_connect
 @ Reset internal state.
 <<Event transforms: evt: TBP>>=
   procedure :: reset => evt_reset
   procedure :: base_reset => evt_reset
 <<Event transforms: procedures>>=
   subroutine evt_reset (evt)
     class(evt_t), intent(inout) :: evt
     evt%rejection_count = 0
     call evt%particle_set%final ()
     evt%particle_set_exists = .false.
   end subroutine evt_reset
 
 @ %def evt_reset
 @ Prepare for a new event: reset internal state, if necessary.  We
 provide MCI and term index of the parent process.
 <<Event transforms: evt: TBP>>=
   procedure (evt_prepare_new_event), deferred :: prepare_new_event
 <<Event transforms: interfaces>>=
   interface
      subroutine evt_prepare_new_event (evt, i_mci, i_term)
        import
        class(evt_t), intent(inout) :: evt
        integer, intent(in) :: i_mci, i_term
      end subroutine evt_prepare_new_event
   end interface
 
 @ %def evt_prepare_new_event
 @ Generate a weighted event, using a valid initiator event in the
 process instance, and the random-number generator.  The returned event
 probability should be a number between zero and one that we can use for
 rejection.
 <<Event transforms: evt: TBP>>=
   procedure (evt_generate_weighted), deferred :: generate_weighted
 <<Event transforms: interfaces>>=
   abstract interface
      subroutine evt_generate_weighted (evt, probability)
        import
        class(evt_t), intent(inout) :: evt
        real(default), intent(inout) :: probability
      end subroutine evt_generate_weighted
   end interface
 
 @ %def evt_generate_weighted
 @ The unweighted event generation routine is actually implemented.  It
 uses the random-number generator for simple rejection.  Of course, the
 implementation may override this and implement a different way of
 generating an unweighted event.
 <<Event transforms: evt: TBP>>=
   procedure :: generate_unweighted => evt_generate_unweighted
   procedure :: base_generate_unweighted => evt_generate_unweighted
 <<Event transforms: procedures>>=
   subroutine evt_generate_unweighted (evt)
     class(evt_t), intent(inout) :: evt
     real(default) :: p, x
     evt%rejection_count = 0
     REJECTION: do
        evt%rejection_count = evt%rejection_count + 1
        call evt%generate_weighted (p)
        if (signal_is_pending ())  return
        call evt%rng%generate (x)
        if (x < p)  exit REJECTION
     end do REJECTION
   end subroutine evt_generate_unweighted
 
 @ %def evt_generate_unweighted
 @ Make a particle set.  This should take the most recent evaluator (or
 whatever stores the event), factorize the density matrix if necessary,
 and store as a particle set.
 
 If applicable, the factorization should make use of the
 [[factorization_mode]] and [[keep_correlations]] settings.
 
 The values [[r]], if set, should control the factorization in more
 detail, e.g., bypassing the random-number generator.
 <<Event transforms: evt: TBP>>=
   procedure (evt_make_particle_set), deferred :: make_particle_set
 <<Event transforms: interfaces>>=
   interface
      subroutine evt_make_particle_set &
           (evt, factorization_mode, keep_correlations, r)
        import
        class(evt_t), intent(inout) :: evt
        integer, intent(in) :: factorization_mode
        logical, intent(in) :: keep_correlations
        real(default), dimension(:), intent(in), optional :: r
      end subroutine evt_make_particle_set
   end interface
 
 @ %def evt_make_particle_set
 @ Copy an existing particle set into the event record.  This bypasses
 all methods to evaluate the internal state, but may be sufficient for
 further processing.
 <<Event transforms: evt: TBP>>=
   procedure :: set_particle_set => evt_set_particle_set
 <<Event transforms: procedures>>=
   subroutine evt_set_particle_set (evt, particle_set, i_mci, i_term)
     class(evt_t), intent(inout) :: evt
     type(particle_set_t), intent(in) :: particle_set
     integer, intent(in) :: i_term, i_mci
     call evt%prepare_new_event (i_mci, i_term)
     evt%particle_set = particle_set
     evt%particle_set_exists = .true.
   end subroutine evt_set_particle_set
 
 @ %def evt_set_particle_set
 @ This procedure can help in the previous task, if the particles are
 available in the form of an interaction object.  (We need two
 interactions, one with color summed over, and one with the probability
 distributed among flows.)
 
 We use the two values from the random number generator for factorizing
 the state.  For testing purposes, we can provide those numbers explicitly.
 <<Event transforms: evt: TBP>>=
   procedure :: factorize_interactions => evt_factorize_interactions
 <<Event transforms: procedures>>=
   subroutine evt_factorize_interactions &
        (evt, int_matrix, int_flows, factorization_mode, &
        keep_correlations, r, qn_select)
     class(evt_t), intent(inout) :: evt
     type(interaction_t), intent(in), target :: int_matrix, int_flows
     integer, intent(in) :: factorization_mode
     logical, intent(in) :: keep_correlations
     real(default), dimension(:), intent(in), optional :: r
     type(quantum_numbers_t), dimension(:), intent(in), optional :: qn_select
     real(default), dimension(2) :: x
     if (present (r)) then
        if (size (r) == 2) then
           x = r
        else
           call msg_bug ("event factorization: size of r array must be 2")
        end if
     else
        call evt%rng%generate (x)
     end if
     call evt%particle_set%init (evt%particle_set_exists, &
          int_matrix, int_flows, factorization_mode, x, &
          keep_correlations, keep_virtual=.true., qn_select = qn_select)
     evt%particle_set_exists = .true.
   end subroutine evt_factorize_interactions
 
 @ %def evt_factorize_interactions
 @
 <<Event transforms: public>>=
   public :: make_factorized_particle_set
 <<Event transforms: procedures>>=
   subroutine make_factorized_particle_set (evt, factorization_mode, &
          keep_correlations, r, ii_term, qn_select)
     class(evt_t), intent(inout) :: evt
     integer, intent(in) :: factorization_mode
     logical, intent(in) :: keep_correlations
     real(default), dimension(:), intent(in), optional :: r
     integer, intent(in), optional :: ii_term
     type(quantum_numbers_t), dimension(:), intent(in), optional :: qn_select
     integer :: i_term
     type(interaction_t), pointer :: int_matrix, int_flows
     if (evt%process_instance%is_complete_event ()) then
        if (present (ii_term)) then
           i_term = ii_term
        else
           i_term = evt%process_instance%select_i_term ()
        end if
        int_matrix => evt%process_instance%get_matrix_int_ptr (i_term)
        int_flows  => evt%process_instance%get_flows_int_ptr (i_term)
        call evt%factorize_interactions (int_matrix, int_flows, &
             factorization_mode, keep_correlations, r, qn_select)
        call evt%tag_incoming ()
     else
        call msg_bug ("Event factorization: event is incomplete")
     end if
   end subroutine make_factorized_particle_set
 
 @ %def make_factorized_particle_set
 @ Mark the incoming particles as incoming in the particle set.  This
 is necessary because in the interaction objects they are usually
 marked as virtual.
 
 In the inquiry functions we set the term index to one; the indices of
 beams and incoming particles should be identical for all process
 terms.
 
 We use the initial elementary process for obtaining the indices.
 Thus, we implicitly assume that the beam and incoming indices stay the
 same across event transforms.  If this is not true for a transform
 (say, MPI), it should override this method.
 <<Event transforms: evt: TBP>>=
   procedure :: tag_incoming => evt_tag_incoming
 <<Event transforms: procedures>>=
   subroutine evt_tag_incoming (evt)
     class(evt_t), intent(inout) :: evt
     integer :: i_term, n_in
     integer, dimension(:), allocatable :: beam_index, in_index
     n_in = evt%process%get_n_in ()
     i_term = 1
     allocate (beam_index (n_in))
     call evt%process_instance%get_beam_index (i_term, beam_index)
     call evt%particle_set%reset_status (beam_index, PRT_BEAM)
     allocate (in_index (n_in))
     call evt%process_instance%get_in_index (i_term, in_index)
     call evt%particle_set%reset_status (in_index, PRT_INCOMING)
   end subroutine evt_tag_incoming
 
 @ %def evt_tag_incoming
 @
 \subsection{Implementation: Trivial transform}
 This transform contains just a pointer to process and process
 instance.  The [[generate]] methods do nothing.
 <<Event transforms: public>>=
   public :: evt_trivial_t
 <<Event transforms: types>>=
   type, extends (evt_t) :: evt_trivial_t
    contains
    <<Event transforms: evt trivial: TBP>>
   end type evt_trivial_t
 
 @ %def evt_trivial_t
 @
 <<Event transforms: evt trivial: TBP>>=
   procedure :: write_name => evt_trivial_write_name
 <<Event transforms: procedures>>=
   subroutine evt_trivial_write_name (evt, unit)
     class(evt_trivial_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A)")  "Event transform: trivial (hard process)"
   end subroutine evt_trivial_write_name
 
 @ %def evt_trivial_write_name
 @ The finalizer is trivial.  Some output:
 <<Event transforms: evt trivial: TBP>>=
   procedure :: write => evt_trivial_write
 <<Event transforms: procedures>>=
   subroutine evt_trivial_write (evt, unit, verbose, more_verbose, testflag)
     class(evt_trivial_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose, more_verbose, testflag
     integer :: u
     u = given_output_unit (unit)
     call write_separator (u, 2)
     call evt%write_name (u)
     call write_separator (u)
     call evt%base_write (u, testflag = testflag)
   end subroutine evt_trivial_write
 
 @ %def evt_trivial_write
 @ Nothing to do here:
 <<Event transforms: evt trivial: TBP>>=
   procedure :: prepare_new_event => evt_trivial_prepare_new_event
 <<Event transforms: procedures>>=
   subroutine evt_trivial_prepare_new_event (evt, i_mci, i_term)
     class(evt_trivial_t), intent(inout) :: evt
     integer, intent(in) :: i_mci, i_term
     call evt%reset ()
   end subroutine evt_trivial_prepare_new_event
 
 @ %def evt_trivial_prepare_new_event
 @ The weighted generator is, surprisingly, trivial.
 <<Event transforms: evt trivial: TBP>>=
   procedure :: generate_weighted => evt_trivial_generate_weighted
 <<Event transforms: procedures>>=
   subroutine evt_trivial_generate_weighted (evt, probability)
     class(evt_trivial_t), intent(inout) :: evt
     real(default), intent(inout) :: probability
     probability = 1
   end subroutine evt_trivial_generate_weighted
 
 @ %def evt_trivial_generate_weighted
 @ This routine makes a particle set, using the associated process
 instance as-is.
 <<Event transforms: evt trivial: TBP>>=
   procedure :: make_particle_set => evt_trivial_make_particle_set
 <<Event transforms: procedures>>=
   subroutine evt_trivial_make_particle_set &
        (evt, factorization_mode, keep_correlations, r)
     class(evt_trivial_t), intent(inout) :: evt
     integer, intent(in) :: factorization_mode
     logical, intent(in) :: keep_correlations
     real(default), dimension(:), intent(in), optional :: r
     call make_factorized_particle_set (evt, factorization_mode, &
          keep_correlations, r)
     evt%particle_set_exists = .true.
   end subroutine evt_trivial_make_particle_set
 
 @ %def event_trivial_make_particle_set
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[event_transforms_ut.f90]]>>=
 <<File header>>
 
 module event_transforms_ut
   use unit_tests
   use event_transforms_uti
 
 <<Standard module head>>
 
 <<Event transforms: public test>>
 
 contains
 
 <<Event transforms: test driver>>
 
 end module event_transforms_ut
 @ %def event_transforms_ut
 @
 <<[[event_transforms_uti.f90]]>>=
 <<File header>>
 
 module event_transforms_uti
 
 <<Use kinds>>
 <<Use strings>>
   use format_utils, only: write_separator
   use os_interface
   use sm_qcd
   use model_data
   use state_matrices, only: FM_IGNORE_HELICITY
   use interactions, only: reset_interaction_counter
   use process_libraries
   use rng_base
   use mci_base
   use mci_midpoint
   use phs_base
   use phs_single
   use prc_core
   use prc_test, only: prc_test_create_library
 
   use process, only: process_t
   use instances, only: process_instance_t
 
   use event_transforms
 
   use rng_base_ut, only: rng_test_factory_t
 
 <<Standard module head>>
 
 <<Event transforms: test declarations>>
 
 contains
 
 <<Event transforms: tests>>
 
 end module event_transforms_uti
 
 @ %def event_transforms_uti
 @ API: driver for the unit tests below.
 <<Event transforms: public test>>=
   public :: event_transforms_test
 <<Event transforms: test driver>>=
   subroutine event_transforms_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Event transforms: execute tests>>
   end subroutine event_transforms_test
 
 @ %def event_transforms_test
 @
 \subsubsection{Test trivial event transform}
 The trivial transform, as an instance of the abstract transform, does
 nothing but to trigger event generation for an elementary process.
 <<Event transforms: execute tests>>=
   call test (event_transforms_1, "event_transforms_1", &
        "trivial event transform", &
        u, results)
 <<Event transforms: test declarations>>=
   public :: event_transforms_1
 <<Event transforms: tests>>=
   subroutine event_transforms_1 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(model_data_t), pointer :: model
     type(process_library_t), target :: lib
     type(string_t) :: libname, procname1, run_id
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     real(default) :: sqrts
     type(process_t), allocatable, target :: process
     type(process_instance_t), allocatable, target :: process_instance
     class(evt_t), allocatable :: evt
     integer :: factorization_mode
     logical :: keep_correlations
 
     write (u, "(A)")  "* Test output: event_transforms_1"
     write (u, "(A)")  "*   Purpose: handle trivial transform"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment and parent process"
     write (u, "(A)")
 
     call os_data_init (os_data)
     allocate (rng_test_factory_t :: rng_factory)
 
     libname = "event_transforms_1_lib"
     procname1 = "event_transforms_1_p"
     run_id = "event_transforms_1"
 
     call prc_test_create_library (libname, lib, &
          scattering = .true., procname1 = procname1)
     call reset_interaction_counter ()
 
     allocate (model)
     call model%init_test ()
 
     allocate (process)
     call process%init (procname1, run_id, &
          lib, os_data, qcd, rng_factory, model)
     call process%setup_test_cores ()
 
     allocate (mci_midpoint_t :: mci_template)
     allocate (phs_single_config_t :: phs_config_template)
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     sqrts = 1000
     call process%setup_beams_sqrts (sqrts, i_core = 1)
     call process%configure_phs ()
     call process%setup_mci ()
     call process%setup_terms ()
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%integrate (1, n_it=1, n_calls=100)
     call process%final_integration (1)
     call process_instance%final ()
     deallocate (process_instance)
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%setup_event_data ()
     call process_instance%init_simulation (1)
 
     write (u, "(A)")  "* Initialize trivial event transform"
     write (u, "(A)")
 
     allocate (evt_trivial_t :: evt)
     model => process%get_model_ptr ()
     call evt%connect (process_instance, model)
 
     write (u, "(A)")  "* Generate event and subsequent transform"
     write (u, "(A)")
 
     call process_instance%generate_unweighted_event (1)
     call process_instance%evaluate_event_data ()
 
     call evt%prepare_new_event (1, 1)
     call evt%generate_unweighted ()
 
     call write_separator (u, 2)
     call evt%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Obtain particle set"
     write (u, "(A)")
 
     factorization_mode = FM_IGNORE_HELICITY
     keep_correlations = .false.
 
     call evt%make_particle_set (factorization_mode, keep_correlations)
 
     call write_separator (u, 2)
     call evt%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt%final ()
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: event_transforms_1"
 
   end subroutine event_transforms_1
 
 @ %def event_transforms_1
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Hadronization interface}
 <<[[hadrons.f90]]>>=
 <<File header>>
 
 module hadrons
 
 <<Use kinds with double>>
 <<Use strings>>
   use io_units
   use format_utils, only: write_separator
   use diagnostics
   use sm_qcd
   use lorentz
   use subevents, only: PRT_OUTGOING
   use particles
   use variables
   use model_data
   use models
   use rng_base
   use hep_common
   use event_transforms
   use shower_base
   use shower_pythia6
   use process
 
 <<Standard module head>>
 
 <<Hadrons: public>>
 
 <<Hadrons: parameters>>
 
 <<Hadrons: types>>
 
 <<Hadrons: interfaces>>
 
 contains
 
 <<Hadrons: procedures>>
 
 end module hadrons
 @ %def hadrons
 @
 \subsection{Hadronization implementations}
 <<Hadrons: public>>=
   public :: HADRONS_UNDEFINED, HADRONS_WHIZARD, HADRONS_PYTHIA6, HADRONS_PYTHIA8
 <<Hadrons: parameters>>=
   integer, parameter :: HADRONS_UNDEFINED = 0
   integer, parameter :: HADRONS_WHIZARD = 1
   integer, parameter :: HADRONS_PYTHIA6 = 2
   integer, parameter :: HADRONS_PYTHIA8 = 3
 @ %def HADRONS_UNDEFINED HADRONS_WHIZARD HADRONS_PYTHIA6 HADRONS_PYTHIA8
 @ A dictionary
 <<Hadrons: public>>=
   public :: hadrons_method
 <<Hadrons: interfaces>>=
   interface hadrons_method
      module procedure hadrons_method_of_string
      module procedure hadrons_method_to_string
   end interface
 <<Hadrons: procedures>>=
   elemental function hadrons_method_of_string (string) result (i)
     integer :: i
     type(string_t), intent(in) :: string
     select case (char(string))
     case ("WHIZARD")
        i = HADRONS_WHIZARD
     case ("PYTHIA6")
        i = HADRONS_PYTHIA6
     case ("PYTHIA8")
        i = HADRONS_PYTHIA8
     case default
        i = HADRONS_UNDEFINED
     end select
   end function hadrons_method_of_string
 
   elemental function hadrons_method_to_string (i) result (string)
     type(string_t) :: string
     integer, intent(in) :: i
     select case (i)
     case (HADRONS_WHIZARD)
        string = "WHIZARD"
     case (HADRONS_PYTHIA6)
        string = "PYTHIA6"
     case (HADRONS_PYTHIA8)
        string = "PYTHIA8"
     case default
        string = "UNDEFINED"
     end select
   end function hadrons_method_to_string
 
 @ %def hadrons_method
 @
 \subsection{Hadronization settings}
 These are the general settings and parameters for the different shower
 methods.
 <<Hadrons: public>>=
   public :: hadron_settings_t
 <<Hadrons: types>>=
   type :: hadron_settings_t
      logical :: active = .false.
      integer :: method = HADRONS_UNDEFINED
      real(default) :: enhanced_fraction = 0
      real(default) :: enhanced_width = 0
    contains
    <<Hadrons: hadron settings: TBP>>
   end type hadron_settings_t
 
 @ %def hadron_settings_t
 @ Read in the hadronization settings.
 <<Hadrons: hadron settings: TBP>>=
   procedure :: init => hadron_settings_init
 <<Hadrons: procedures>>=
   subroutine hadron_settings_init (hadron_settings, var_list)
     class(hadron_settings_t), intent(out) :: hadron_settings
     type(var_list_t), intent(in) :: var_list
     hadron_settings%active = &
          var_list%get_lval (var_str ("?hadronization_active"))
     hadron_settings%method = hadrons_method_of_string ( &
          var_list%get_sval (var_str ("$hadronization_method")))
     hadron_settings%enhanced_fraction = &
          var_list%get_rval (var_str ("hadron_enhanced_fraction"))
     hadron_settings%enhanced_width = &
          var_list%get_rval (var_str ("hadron_enhanced_width"))
   end subroutine hadron_settings_init
 
 @ %def hadron_settings_init
 @
 <<Hadrons: hadron settings: TBP>>=
   procedure :: write => hadron_settings_write
 <<Hadrons: procedures>>=
   subroutine hadron_settings_write (settings, unit)
     class(hadron_settings_t), intent(in) :: settings
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     write (u, "(1x,A)")  "Hadronization settings:"
     call write_separator (u)
     write (u, "(1x,A)")  "Master switches:"
     write (u, "(3x,A,1x,L1)") &
          "active                = ", settings%active
     write (u, "(1x,A)")  "General settings:"
     if (settings%active) then
        write (u, "(3x,A)") &
             "hadron_method         =  " // &
             char (hadrons_method_to_string (settings%method))
     else
        write (u, "(3x,A)") " [Hadronization off]"
     end if
     write (u, "(1x,A)")  "pT generation parameters"
     write (u, "(3x,A,1x,ES19.12)") &
          "enhanced_fraction     = ", settings%enhanced_fraction
     write (u, "(3x,A,1x,ES19.12)") &
          "enhanced_width        = ", settings%enhanced_width
   end subroutine hadron_settings_write
 
 @ %def hadron_settings_write
 @
 \subsection{Abstract Hadronization Type}
 The [[model]] is the fallback model including all hadrons
 <<Hadrons: types>>=
   type, abstract :: hadrons_t
      class(rng_t), allocatable :: rng
      type(shower_settings_t) :: shower_settings
      type(hadron_settings_t) :: hadron_settings
      type(model_t), pointer :: model => null()
    contains
    <<Hadrons: hadrons: TBP>>
   end type hadrons_t
 
 @ %def hadrons_t
 @
 <<Hadrons: hadrons: TBP>>=
   procedure (hadrons_init), deferred :: init
 <<Hadrons: interfaces>>=
   abstract interface
     subroutine hadrons_init &
          (hadrons, shower_settings, hadron_settings, model_hadrons)
       import
       class(hadrons_t), intent(out) :: hadrons
       type(shower_settings_t), intent(in) :: shower_settings
       type(hadron_settings_t), intent(in) :: hadron_settings
       type(model_t), target, intent(in) :: model_hadrons
     end subroutine hadrons_init
    end interface
 
 @ %def hadrons_init
 @
 <<Hadrons: hadrons: TBP>>=
   procedure (hadrons_hadronize), deferred :: hadronize
 <<Hadrons: interfaces>>=
   abstract interface
      subroutine hadrons_hadronize (hadrons, particle_set, valid)
        import
        class(hadrons_t), intent(inout) :: hadrons
        type(particle_set_t), intent(in) :: particle_set
        logical, intent(out) :: valid
      end subroutine hadrons_hadronize
   end interface
 @ %def hadrons_hadronize
 @
 <<Hadrons: hadrons: TBP>>=
   procedure (hadrons_make_particle_set), deferred :: make_particle_set
 <<Hadrons: interfaces>>=
   abstract interface
      subroutine hadrons_make_particle_set (hadrons, particle_set, &
           model, valid)
        import
        class(hadrons_t), intent(in) :: hadrons
        type(particle_set_t), intent(inout) :: particle_set
        class(model_data_t), intent(in), target :: model
        logical, intent(out) :: valid
      end subroutine hadrons_make_particle_set
   end interface
 
 @ %def hadrons_make_particle_set
 @
 <<Hadrons: hadrons: TBP>>=
   procedure :: import_rng => hadrons_import_rng
 <<Hadrons: procedures>>=
   pure subroutine hadrons_import_rng (hadrons, rng)
     class(hadrons_t), intent(inout) :: hadrons
     class(rng_t), intent(inout), allocatable :: rng
     call move_alloc (from = rng, to = hadrons%rng)
   end subroutine hadrons_import_rng
 
 @ %def hadrons_import_rng
 @
 \subsection{[[WHIZARD]] Hadronization Type}
 Hadronization can be (incompletely) performed through \whizard's internal
 routine.
 <<Hadrons: public>>=
   public :: hadrons_hadrons_t
 <<Hadrons: types>>=
   type, extends (hadrons_t) :: hadrons_hadrons_t
      contains
        <<Hadrons: hadrons hadrons: TBP>>
     end type hadrons_hadrons_t
 
 @ %def hadrons_hadrons_t
 @
 <<Hadrons: hadrons hadrons: TBP>>=
   procedure :: init => hadrons_hadrons_init
 <<Hadrons: procedures>>=
   subroutine hadrons_hadrons_init &
        (hadrons, shower_settings, hadron_settings, model_hadrons)
     class(hadrons_hadrons_t), intent(out) :: hadrons
     type(shower_settings_t), intent(in) :: shower_settings
     type(hadron_settings_t), intent(in) :: hadron_settings
     type(model_t), intent(in), target :: model_hadrons
     hadrons%model => model_hadrons
     hadrons%shower_settings = shower_settings
     hadrons%hadron_settings = hadron_settings
     call msg_message &
          ("Hadronization: WHIZARD model for hadronization and decays")
   end subroutine hadrons_hadrons_init
 
 @ %def hadrons_hadrons_init
 @
 <<Hadrons: hadrons hadrons: TBP>>=
   procedure :: hadronize => hadrons_hadrons_hadronize
 <<Hadrons: procedures>>=
   subroutine hadrons_hadrons_hadronize (hadrons, particle_set, valid)
     class(hadrons_hadrons_t), intent(inout) :: hadrons
     type(particle_set_t), intent(in) :: particle_set
     logical, intent(out) :: valid
     integer, dimension(:), allocatable :: cols, acols, octs
     integer :: n
     if (signal_is_pending ()) return
     call msg_debug (D_TRANSFORMS, "hadrons_hadrons_hadronize")
     call particle_set%write (6, compressed=.true.)
     n = particle_set%get_n_tot ()
     allocate (cols (n), acols (n), octs (n))
     call extract_color_systems (particle_set, cols, acols, octs)
     print *, "size(cols)  = ", size (cols)
     if (size(cols) > 0) then
        print *, "cols  = ", cols
     end if
     print *, "size(acols) = ", size(acols)
     if (size(acols) > 0) then
        print *, "acols = ", acols
     end if
     print *, "size(octs)  = ", size(octs)
     if (size (octs) > 0) then
        print *, "octs  = ", octs
     end if
     !!! if all arrays are empty, i.e. zero particles found, nothing to do
   end subroutine hadrons_hadrons_hadronize
 
 @ %def hadrons_hadrons_hadronize
 @ This type contains a flavor selector for the creation of hadrons,
 including parameters for the special handling of baryons.
 <<Hadrons: public>>=
   public :: had_flav_t
 <<Hadrons: types>>=
   type had_flav_t
   end type had_flav_t
 
 @ %def had_flav_t
 @ This is the type for the ends of Lund strings.
 <<Hadrons: public>>=
   public :: lund_end
 <<Hadrons: types>>=
   type lund_end
      logical :: from_pos
      integer :: i_end
      integer :: i_max
      integer :: id_had
      integer :: i_pos_old
      integer :: i_neg_old
      integer :: i_pos_new
      integer :: i_neg_new
      real(default) :: px_old
      real(default) :: py_old
      real(default) :: px_new
      real(default) :: py_new
      real(default) :: px_had
      real(default) :: py_had
      real(default) :: m_had
      real(default) :: mT2_had
      real(default) :: z_had
      real(default) :: gamma_old
      real(default) :: gamma_new
      real(default) :: x_pos_old
      real(default) :: x_pos_new
      real(default) :: x_pos_had
      real(default) :: x_neg_old
      real(default) :: x_neg_new
      real(default) :: x_neg_had
      type(had_flav_t) :: old_flav
      type(had_flav_t) :: new_flav
      type(vector4_t) :: p_had
      type(vector4_t) :: p_pre
   end type lund_end
 
 @ %def lund_end
 @ Generator for transverse momentum for the fragmentation.
 <<Hadrons: public>>=
   public :: lund_pt_t
 <<Hadrons: types>>=
   type lund_pt_t
      real(default) :: sigma_min
      real(default) :: sigma_q
      real(default) :: enhanced_frac
      real(default) :: enhanced_width
      real(default) :: sigma_to_had
      class(rng_t), allocatable :: rng
    contains
    <<Hadrons: lund pT: TBP>>
   end type lund_pt_t
 
 @ %def lund_pt
 <<Hadrons: lund pT: TBP>>=
   procedure :: init => lund_pt_init
 <<Hadrons: procedures>>=
   subroutine lund_pt_init (lund_pt, settings)
     class (lund_pt_t), intent(out) :: lund_pt
     type(hadron_settings_t), intent(in) :: settings
   end subroutine lund_pt_init
 
 @ %def lund_pt_init
 @
 <<Hadrons: hadrons hadrons: TBP>>=
   procedure :: make_particle_set => hadrons_hadrons_make_particle_set
 <<Hadrons: procedures>>=
   subroutine hadrons_hadrons_make_particle_set &
          (hadrons, particle_set, model, valid)
     class(hadrons_hadrons_t), intent(in) :: hadrons
     type(particle_set_t), intent(inout) :: particle_set
     class(model_data_t), intent(in), target :: model
     logical, intent(out) :: valid
     if (signal_is_pending ()) return
     valid = .false.
     if (valid) then
     else
        call msg_fatal ("WHIZARD hadronization not yet implemented")
     end if
   end subroutine hadrons_hadrons_make_particle_set
 
 @ %def hadrons_hadrons_make_particle_set
 @
 <<Hadrons: procedures>>=
   subroutine extract_color_systems (p_set, cols, acols, octs)
     type(particle_set_t), intent(in) :: p_set
     integer, dimension(:), allocatable, intent(out) :: cols, acols, octs
     logical, dimension(:), allocatable :: mask
     integer :: i, n, n_cols, n_acols, n_octs
     n = p_set%get_n_tot ()
     allocate (mask (n))
     do i = 1, n
        mask(i) = p_set%prt(i)%col%get_col () /= 0 .and. &
             p_set%prt(i)%col%get_acl () == 0 .and. &
             p_set%prt(i)%get_status () == PRT_OUTGOING
     end do
     n_cols = count (mask)
     allocate (cols (n_cols))
     cols = p_set%get_indices (mask)
     do i = 1, n
        mask(i) = p_set%prt(i)%col%get_col () == 0 .and. &
             p_set%prt(i)%col%get_acl () /= 0 .and. &
             p_set%prt(i)%get_status () == PRT_OUTGOING
     end do
     n_acols = count (mask)
     allocate (acols (n_acols))
     acols = p_set%get_indices (mask)
     do i = 1, n
        mask(i) = p_set%prt(i)%col%get_col () /= 0 .and. &
             p_set%prt(i)%col%get_acl () /= 0 .and. &
             p_set%prt(i)%get_status () == PRT_OUTGOING
     end do
     n_octs = count (mask)
     allocate (octs (n_octs))
     octs = p_set%get_indices (mask)
   end subroutine extract_color_systems
 
 @ %def extract_color_systems
 @
 \subsection{[[PYTHIA6]] Hadronization Type}
 Hadronization via [[PYTHIA6]] is at another option for
 hadronization within \whizard.
 <<Hadrons: public>>=
   public :: hadrons_pythia6_t
 <<Hadrons: types>>=
   type, extends (hadrons_t) :: hadrons_pythia6_t
    contains
    <<Hadrons: hadrons pythia6: TBP>>
   end type hadrons_pythia6_t
 
 @ %def hadrons_pythia6_t
 <<Hadrons: hadrons pythia6: TBP>>=
   procedure :: init => hadrons_pythia6_init
 <<Hadrons: procedures>>=
   subroutine hadrons_pythia6_init &
        (hadrons, shower_settings, hadron_settings, model_hadrons)
     class(hadrons_pythia6_t), intent(out) :: hadrons
     type(shower_settings_t), intent(in) :: shower_settings
     type(hadron_settings_t), intent(in) :: hadron_settings
     type(model_t), intent(in), target :: model_hadrons
     logical :: pygive_not_set_by_shower
     hadrons%model => model_hadrons
     hadrons%shower_settings = shower_settings
     hadrons%hadron_settings = hadron_settings
     pygive_not_set_by_shower = .not. (shower_settings%method == PS_PYTHIA6 &
          .and. (shower_settings%isr_active .or. shower_settings%fsr_active))
     if (pygive_not_set_by_shower) then
        call pythia6_set_verbose (shower_settings%verbose)
        call pythia6_set_config (shower_settings%pythia6_pygive)
     end if
     call msg_message &
          ("Hadronization: Using PYTHIA6 interface for hadronization and decays")
   end subroutine hadrons_pythia6_init
 
 @ %def hadrons_pythia6_init
 @ Assume that the event record is still in the PYTHIA COMMON BLOCKS
 transferred there by the WHIZARD or PYTHIA6 shower routines.
 <<Hadrons: hadrons pythia6: TBP>>=
   procedure :: hadronize => hadrons_pythia6_hadronize
 <<Hadrons: procedures>>=
   subroutine hadrons_pythia6_hadronize (hadrons, particle_set, valid)
     class(hadrons_pythia6_t), intent(inout) :: hadrons
     type(particle_set_t), intent(in) :: particle_set
     logical, intent(out) :: valid
     integer :: N, NPAD, K
     real(double) :: P, V
     common /PYJETS/ N, NPAD, K(4000,5), P(4000,5), V(4000,5)
     save /PYJETS/
     if (signal_is_pending ()) return
     call msg_debug (D_TRANSFORMS, "hadrons_pythia6_hadronize")
     call pygive ("MSTP(111)=1")    !!! Switch on hadronization and decays
     call pygive ("MSTJ(1)=1")      !!! String fragmentation
     call pygive ("MSTJ(21)=2")     !!! String fragmentation keeping resonance momentum
     call pygive ("MSTJ(28)=0")     !!! Switch off tau decays
     if (debug_active (D_TRANSFORMS)) then
        call msg_debug (D_TRANSFORMS, "N", N)
        call pylist(2)
        print *, ' line 7 : ', k(7,1:5), p(7,1:5)
     end if
     call pyedit (12)
     call pythia6_set_last_treated_line (N)
     call pyexec ()
     call pyedit (12)
     valid = .true.
   end subroutine hadrons_pythia6_hadronize
 
 @ %def hadrons_pythia6_hadronize
 @
 <<Hadrons: hadrons pythia6: TBP>>=
   procedure :: make_particle_set => hadrons_pythia6_make_particle_set
 <<Hadrons: procedures>>=
   subroutine hadrons_pythia6_make_particle_set &
          (hadrons, particle_set, model, valid)
     class(hadrons_pythia6_t), intent(in) :: hadrons
     type(particle_set_t), intent(inout) :: particle_set
     class(model_data_t), intent(in), target :: model
     logical, intent(out) :: valid
     if (signal_is_pending ()) return
     valid = pythia6_handle_errors ()
     if (valid) then
        call pythia6_combine_with_particle_set &
             (particle_set, model, hadrons%model, hadrons%shower_settings)
     end if
   end subroutine hadrons_pythia6_make_particle_set
 
 @ %def hadrons_pythia6_make_particle_set
 @
 \subsection{[[Pythia8]] Hadronization Type}
 <<Hadrons: public>>=
   public :: hadrons_pythia8_t
 <<Hadrons: types>>=
   type,extends (hadrons_t) :: hadrons_pythia8_t
   contains
    <<Hadrons: hadrons pythia8: TBP>>
   end type hadrons_pythia8_t
 
 @ %def hadrons_pythia8_t
 @
 <<Hadrons: hadrons pythia8: TBP>>=
   procedure :: init => hadrons_pythia8_init
 <<Hadrons: procedures>>=
   subroutine hadrons_pythia8_init &
        (hadrons, shower_settings, hadron_settings, model_hadrons)
     class(hadrons_pythia8_t), intent(out) :: hadrons
     type(shower_settings_t), intent(in) :: shower_settings
     type(hadron_settings_t), intent(in) :: hadron_settings
     type(model_t), intent(in), target :: model_hadrons
     logical :: options_not_set_by_shower
     hadrons%shower_settings = shower_settings
     hadrons%hadron_settings = hadron_settings
     options_not_set_by_shower = .not. (shower_settings%method == PS_PYTHIA8 &
          .and. (shower_settings%isr_active .or. shower_settings%fsr_active))
     if (options_not_set_by_shower) then
        !call pythia8_set_verbose (settings%verbose)
        !call pythia8_set_config (settings%pythia8_config)
        !call pythia8_set_config_file (settings%pythia8_config_file)
     end if
     call msg_message &
          ("Using Pythia8 interface for hadronization and decays")
   end subroutine hadrons_pythia8_init
 
 @ %def hadrons_pythia8_init
 @
 <<Hadrons: hadrons pythia8: TBP>>=
   procedure :: hadronize => hadrons_pythia8_hadronize
 <<Hadrons: procedures>>=
   subroutine hadrons_pythia8_hadronize (hadrons, particle_set, valid)
     class(hadrons_pythia8_t), intent(inout) :: hadrons
     type(particle_set_t), intent(in) :: particle_set
     logical, intent(out) :: valid
     ! call pythia8_hadronize
     valid = .true.
   end subroutine hadrons_pythia8_hadronize
 
 @ %def hadrons_pythia8_hadronize
 @
 <<Hadrons: hadrons pythia8: TBP>>=
   procedure :: make_particle_set => hadrons_pythia8_make_particle_set
 <<Hadrons: procedures>>=
   subroutine hadrons_pythia8_make_particle_set &
          (hadrons, particle_set, model, valid)
     class(hadrons_pythia8_t), intent(in) :: hadrons
     type(particle_set_t), intent(inout) :: particle_set
     class(model_data_t), intent(in), target :: model
     logical, intent(out) :: valid
     ! call pythia8_combine_particle_set
     valid = .true.
   end subroutine hadrons_pythia8_make_particle_set
 
 @ %def hadrons_pythia8_make_particle_set
 @
 \subsection{Hadronization Event Transform}
 This is the type for the hadronization event transform.  It does not
 depend on the specific hadronization implementation of
 [[hadrons_t]].
 <<Hadrons: public>>=
   public :: evt_hadrons_t
 <<Hadrons: types>>=
   type, extends (evt_t) :: evt_hadrons_t
      class(hadrons_t), allocatable :: hadrons
      type(model_t), pointer :: model_hadrons => null()
      type(qcd_t), pointer :: qcd_t => null()
      logical :: is_first_event
    contains
    <<Hadrons: evt hadrons: TBP>>
   end type evt_hadrons_t
 
 @ %def evt_hadrons_t
 @ Initialize the parameters.  The [[model_hadrons]] is supposed to be
 the SM variant that contains all hadrons that may be generated in the
 shower.
 <<Hadrons: evt hadrons: TBP>>=
   procedure :: init => evt_hadrons_init
 <<Hadrons: procedures>>=
   subroutine evt_hadrons_init (evt, model_hadrons)
     class(evt_hadrons_t), intent(out) :: evt
     type(model_t), intent(in), target :: model_hadrons
     evt%model_hadrons => model_hadrons
     evt%is_first_event = .true.
   end subroutine evt_hadrons_init
 
 @ %def evt_hadrons_init
 @
 <<Hadrons: evt hadrons: TBP>>=
   procedure :: write_name => evt_hadrons_write_name
 <<Hadrons: procedures>>=
   subroutine evt_hadrons_write_name (evt, unit)
     class(evt_hadrons_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A)")  "Event transform: hadronization"
   end subroutine evt_hadrons_write_name
 
 @ %def evt_hadrons_write_name
 @ Output.
 <<Hadrons: evt hadrons: TBP>>=
   procedure :: write => evt_hadrons_write
 <<Hadrons: procedures>>=
   subroutine evt_hadrons_write (evt, unit, verbose, more_verbose, testflag)
     class(evt_hadrons_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose, more_verbose, testflag
     integer :: u
     u = given_output_unit (unit)
     call write_separator (u, 2)
     call evt%write_name (u)
     call write_separator (u)
     call evt%base_write (u, testflag = testflag, show_set = .false.)
     if (evt%particle_set_exists)  &
          call evt%particle_set%write &
          (u, summary = .true., compressed = .true., testflag = testflag)
     call write_separator (u)
     call evt%hadrons%shower_settings%write (u)
     call write_separator (u)
     call evt%hadrons%hadron_settings%write (u)
   end subroutine evt_hadrons_write
 
 @ %def evt_hadrons_write
 @
 <<Hadrons: evt hadrons: TBP>>=
   procedure :: first_event => evt_hadrons_first_event
 <<Hadrons: procedures>>=
   subroutine evt_hadrons_first_event (evt)
     class(evt_hadrons_t), intent(inout) :: evt
     call msg_debug (D_TRANSFORMS, "evt_hadrons_first_event")
     associate (settings => evt%hadrons%shower_settings)
        settings%hadron_collision = .false.
        !!! !!! !!! Workaround for PGF90 16.1
        !!! if (all (evt%particle_set%prt(1:2)%flv%get_pdg_abs () <= 39)) then
        if (evt%particle_set%prt(1)%flv%get_pdg_abs () <= 39 .and. &
            evt%particle_set%prt(2)%flv%get_pdg_abs () <= 39) then
           settings%hadron_collision = .false.
        !!! else if (all (evt%particle_set%prt(1:2)%flv%get_pdg_abs () >= 100)) then
        else if (evt%particle_set%prt(1)%flv%get_pdg_abs () >= 100 .and. &
                 evt%particle_set%prt(2)%flv%get_pdg_abs () >= 100) then
           settings%hadron_collision = .true.
        else
           call msg_fatal ("evt_hadrons didn't recognize beams setup")
        end if
        call msg_debug (D_TRANSFORMS, "hadron_collision", settings%hadron_collision)
        if (.not. (settings%isr_active .or. settings%fsr_active)) then
           call msg_fatal ("Hadronization without shower is not supported")
        end if
     end associate
     evt%is_first_event = .false.
   end subroutine evt_hadrons_first_event
 
 @ %def evt_hadrons_first_event
 @ Here we take the particle set from the previous event transform and
 apply the hadronization.  The result is stored in the [[evt%hadrons]]
 object.  We always return a probability of unity as we don't have the
 analytic weight of the hadronization.  Invalid events have to be
 discarded by the caller which is why we mark the particle set as
 invalid.
 <<Hadrons: evt hadrons: TBP>>=
   procedure :: generate_weighted => evt_hadrons_generate_weighted
 <<Hadrons: procedures>>=
   subroutine evt_hadrons_generate_weighted (evt, probability)
     class(evt_hadrons_t), intent(inout) :: evt
     real(default), intent(inout) :: probability
     logical :: valid
     if (signal_is_pending ())  return
     evt%particle_set = evt%previous%particle_set
     if (evt%is_first_event) then
        call evt%first_event ()
     end if
     call evt%hadrons%hadronize (evt%particle_set, valid)
     probability = 1
     evt%particle_set_exists = valid
   end subroutine evt_hadrons_generate_weighted
 
 @ %def evt_hadrons_generate_weighted
 @ The factorization parameters are irrelevant.
 <<Hadrons: evt hadrons: TBP>>=
   procedure :: make_particle_set => evt_hadrons_make_particle_set
 <<Hadrons: procedures>>=
   subroutine evt_hadrons_make_particle_set &
        (evt, factorization_mode, keep_correlations, r)
     class(evt_hadrons_t), intent(inout) :: evt
     integer, intent(in) :: factorization_mode
     logical, intent(in) :: keep_correlations
     real(default), dimension(:), intent(in), optional :: r
     logical :: valid
     call evt%hadrons%make_particle_set (evt%particle_set, evt%model, valid)
     evt%particle_set_exists = evt%particle_set_exists .and. valid
   end subroutine evt_hadrons_make_particle_set
 
 @ %def event_hadrons_make_particle_set
 @ Create RNG instances, spawned by the process object.
 <<Hadrons: evt hadrons: TBP>>=
   procedure :: make_rng => evt_hadrons_make_rng
 <<Hadrons: procedures>>=
   subroutine evt_hadrons_make_rng (evt, process)
     class(evt_hadrons_t), intent(inout) :: evt
     type(process_t), intent(inout) :: process
     class(rng_t), allocatable :: rng
     call process%make_rng (rng)
     call evt%hadrons%import_rng (rng)
   end subroutine evt_hadrons_make_rng
 
 @ %def evt_hadrons_make_rng
 @
 <<Hadrons: evt hadrons: TBP>>=
   procedure :: prepare_new_event => evt_hadrons_prepare_new_event
 <<Hadrons: procedures>>=
   subroutine evt_hadrons_prepare_new_event (evt, i_mci, i_term)
     class(evt_hadrons_t), intent(inout) :: evt
     integer, intent(in) :: i_mci, i_term
     call evt%reset ()
   end subroutine evt_hadrons_prepare_new_event
 
 @ %def evt_hadrons_prepare_new_event
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Resonance Insertion}
 <<[[resonance_insertion.f90]]>>=
 <<File header>>
 
 module resonance_insertion
 
 <<Use kinds>>
 <<Use strings>>
   use io_units
   use format_utils, only: write_separator
   use format_defs, only: FMT_12
   use rng_base, only: rng_t
   use selectors, only: selector_t
   use sm_qcd
   use model_data
   use interactions, only: interaction_t
   use particles, only: particle_t, particle_set_t
   use subevents, only: PRT_RESONANT
   use models
   use resonances, only: resonance_history_set_t
   use resonances, only: resonance_tree_t
   use instances, only: process_instance_ptr_t
   use event_transforms
 
 <<Standard module head>>
 
 <<Resonance insertion: public>>
 
 <<Resonance insertion: types>>
 
 contains
 
 <<Resonance insertion: procedures>>
 
 end module resonance_insertion
 @ %def resonance_insertion
 @
 \subsection{Resonance-Insertion Event Transform}
 This is the type for the event transform that applies resonance insertion.
 The resonance history set describe the resonance histories that we may
 consider.  There is a process library with process objects that correspond to
 the resonance histories.  Library creation, compilation etc.\ is done outside
 the scope of this module.
 <<Resonance insertion: public>>=
   public :: evt_resonance_t
 <<Resonance insertion: types>>=
   type, extends (evt_t) :: evt_resonance_t
      type(resonance_history_set_t), dimension(:), allocatable :: res_history_set
      integer, dimension(:), allocatable :: index_offset
      integer :: selected_component = 0
      type(string_t) :: libname
      type(string_t), dimension(:), allocatable :: proc_id
      real(default) :: on_shell_limit = 0
      real(default) :: on_shell_turnoff = 0
      real(default) :: background_factor = 1
      logical :: selector_active = .false.
      type(selector_t) :: selector
      integer :: selected_history = 0
      type(process_instance_ptr_t), dimension(:), allocatable :: instance
    contains
    <<Resonance insertion: evt resonance: TBP>>
   end type evt_resonance_t
 
 @ %def evt_resonance_t
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: write_name => evt_resonance_write_name
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_write_name (evt, unit)
     class(evt_resonance_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A)")  "Event transform: resonance insertion"
   end subroutine evt_resonance_write_name
 
 @ %def evt_resonance_write_name
 @ Output.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: write => evt_resonance_write
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_write (evt, unit, verbose, more_verbose, testflag)
     class(evt_resonance_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose, more_verbose, testflag
     integer :: u, i
     u = given_output_unit (unit)
     call write_separator (u, 2)
     call evt%write_name (u)
     call write_separator (u, 2)
     write (u, "(1x,A,A,A)")  "Process library = '", char (evt%libname), "'"
     if (allocated (evt%res_history_set)) then
        do i = 1, size (evt%res_history_set)
           if (i == evt%selected_component) then
              write (u, "(1x,A,I0,A)")  "Component #", i, ": *"
           else
              write (u, "(1x,A,I0,A)")  "Component #", i, ":"
           end if
           call evt%res_history_set(i)%write (u, indent=1)
        end do
     end if
     call write_separator (u)
     if (allocated (evt%instance)) then
        write (u, "(1x,A)")  "Subprocess instances: allocated"
     else
        write (u, "(1x,A)")  "Subprocess instances: not allocated"
     end if
     if (evt%particle_set_exists) then
        if (evt%selected_history > 0) then
           write (u, "(1x,A,I0)")  "Selected: resonance history #", &
                evt%selected_history
        else
           write (u, "(1x,A)")  "Selected: no resonance history"
        end if
     else
        write (u, "(1x,A)")  "Selected: [none]"
     end if
     write (u, "(1x,A,1x," // FMT_12 // ")")  &
          "On-shell limit    =", evt%on_shell_limit
     write (u, "(1x,A,1x," // FMT_12 // ")")  &
          "On-shell turnoff  =", evt%on_shell_turnoff
     write (u, "(1x,A,1x," // FMT_12 // ")")  &
          "Background factor =", evt%background_factor
     call write_separator (u)
     if (evt%selector_active) then
        write (u, "(2x)", advance="no")
        call evt%selector%write (u, testflag=testflag)
        call write_separator (u)
     end if
     call evt%base_write (u, testflag = testflag, show_set = .false.)
     call write_separator (u)
     if (evt%particle_set_exists) then
        call evt%particle_set%write &
             (u, summary = .true., compressed = .true., testflag = testflag)
        call write_separator (u)
     end if
   end subroutine evt_resonance_write
 
 @ %def evt_resonance_write
 @
 \subsection{Set contained data}
 Insert the resonance data, in form of a pre-generated resonance
 history set.  Accumulate the number of histories for each set, to
 initialize an array of index offsets for lookup.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: set_resonance_data => evt_resonance_set_resonance_data
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_set_resonance_data (evt, res_history_set)
     class(evt_resonance_t), intent(inout) :: evt
     type(resonance_history_set_t), dimension(:), intent(in) :: res_history_set
     integer :: i
     evt%res_history_set = res_history_set
     allocate (evt%index_offset (size (evt%res_history_set)), source = 0)
     do i = 2, size (evt%res_history_set)
        evt%index_offset(i) = &
             evt%index_offset(i-1) + evt%res_history_set(i-1)%get_n_history ()
     end do
   end subroutine evt_resonance_set_resonance_data
   
 @ %def evt_resonance_set_resonance_data  
 @ Set the library that contains the resonant subprocesses.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: set_library => evt_resonance_set_library
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_set_library (evt, libname)
     class(evt_resonance_t), intent(inout) :: evt
     type(string_t), intent(in) :: libname
     evt%libname = libname
   end subroutine evt_resonance_set_library
 
 @ %def evt_resonance_set_library
 @ Assign pointers to subprocess instances.  Once a subprocess has been
 selected, the instance is used for generating the particle set with
 valid quantum-number assignments, ready for resonance insertion.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: set_subprocess_instances &
        => evt_resonance_set_subprocess_instances
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_set_subprocess_instances (evt, instance)
     class(evt_resonance_t), intent(inout) :: evt
     type(process_instance_ptr_t), dimension(:), intent(in) :: instance
     evt%instance = instance
   end subroutine evt_resonance_set_subprocess_instances
   
 @ %def evt_resonance_set_subprocess_instances
 @ Set the on-shell limit, the relative distance from a resonance that
 is still considered to be on-shell.  The probability for being
 considered on-shell can be reduced by the turnoff parameter below.
 For details, see the [[resonances]] module.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: set_on_shell_limit => evt_resonance_set_on_shell_limit
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_set_on_shell_limit (evt, on_shell_limit)
     class(evt_resonance_t), intent(inout) :: evt
     real(default), intent(in) :: on_shell_limit
     evt%on_shell_limit = on_shell_limit
   end subroutine evt_resonance_set_on_shell_limit
   
 @ %def evt_resonance_set_on_shell_limit
 @ Set the Gaussian on-shell turnoff parameter, the width of the
 weighting factor for the resonance squared matrix element.  If the
 resonance is off shell, this factor reduces the weight of the matrix
 element in the selector, such that the probability for considered
 resonant is reduced.  The factor is applied only if the offshellness
 is less than the [[on_shell_limit]] above.  For details, see the
 [[resonances]] module.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: set_on_shell_turnoff => evt_resonance_set_on_shell_turnoff
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_set_on_shell_turnoff (evt, on_shell_turnoff)
     class(evt_resonance_t), intent(inout) :: evt
     real(default), intent(in) :: on_shell_turnoff
     evt%on_shell_turnoff = on_shell_turnoff
   end subroutine evt_resonance_set_on_shell_turnoff
   
 @ %def evt_resonance_set_on_shell_turnoff
 @ Reweight (suppress) the background contribution if there is a resonance
 history that applies.  The event will be registered as background if there is
 no applicable resonance history, or if the background configuration has been
 selected based on (reweighted) squared matrix elements.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: set_background_factor => evt_resonance_set_background_factor
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_set_background_factor (evt, background_factor)
     class(evt_resonance_t), intent(inout) :: evt
     real(default), intent(in) :: background_factor
     evt%background_factor = background_factor
   end subroutine evt_resonance_set_background_factor
   
 @ %def evt_resonance_set_background_factor
 @
 \subsection{Selector}
 Manually import a random-number generator object.  This should be
 done only for testing purposes.  The standard procedure is to
 [[connect]] a process to an event transform; this will create an
 appropriate [[rng]] from the RNG factory in the process object.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: import_rng => evt_resonance_import_rng
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_import_rng (evt, rng)
     class(evt_resonance_t), intent(inout) :: evt
     class(rng_t), allocatable, intent(inout) :: rng
     call move_alloc (from = rng, to = evt%rng)
   end subroutine evt_resonance_import_rng
 
 @ %def evt_resonance_import_rng
 @
 We use a standard selector object to choose from the available resonance
 histories.  If the selector is inactive, we do not insert resonances.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: write_selector => evt_resonance_write_selector
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_write_selector (evt, unit, testflag)
     class(evt_resonance_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: testflag
     integer :: u
     u = given_output_unit (unit)
     if (evt%selector_active) then
        call evt%selector%write (u, testflag)
     else
        write (u, "(1x,A)")  "Selector: [inactive]"
     end if
   end subroutine evt_resonance_write_selector
     
 @ %def evt_resonance_write_selector
 @
 The selector is initialized with relative weights of
 histories which need not be normalized.  Channels with weight zero are
 ignored.
 
 The [[offset]] will normally be $-1$, so we count from zero, and zero
 is a valid result from the selector.  Selecting the zero entry implies
 no resonance insertion.  However, this behavior is not hard-coded
 here (without offset, no resonance is not possible as a result).
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: init_selector => evt_resonance_init_selector
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_init_selector (evt, weight, offset)
     class(evt_resonance_t), intent(inout) :: evt
     real(default), dimension(:), intent(in) :: weight
     integer, intent(in), optional :: offset
     if (any (weight > 0)) then
        call evt%selector%init (weight, offset = offset)
        evt%selector_active = .true.
     else
        evt%selector_active = .false.
     end if
   end subroutine evt_resonance_init_selector
     
 @ %def evt_resonance_init_selector
 @ Return all selector weights, for inspection.  Note that the index
 counts from zero.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: get_selector_weights => evt_resonance_get_selector_weights
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_get_selector_weights (evt, weight)
     class(evt_resonance_t), intent(in) :: evt
     real(default), dimension(0:), intent(out) :: weight
     integer :: i
     do i = 0, ubound (weight,1)
        weight(i) = evt%selector%get_weight (i)
     end do
   end subroutine evt_resonance_get_selector_weights
   
 @ %def evt_resonance_get_selector_weights
 @
 \subsection{Runtime calculations}
 Use the associated master process instance and the subprocess
 instances to distribute the current momentum set, then compute the
 squared matrix elements weights for all subprocesses.
 
 NOTE: Procedures in this subsection are not covered by unit tests
 in this module, but by unit tests of the [[restricted_subprocesses]]
 module.
 
 Fill the particle set, so the momentum configuration can be used by
 the subprocess instances.  The standard workflow is to copy from the
 previous particle set.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: fill_momenta => evt_resonance_fill_momenta
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_fill_momenta (evt)
     class(evt_resonance_t), intent(inout) :: evt
     integer :: i, n
     if (associated (evt%previous)) then
        evt%particle_set = evt%previous%particle_set
     else if (associated (evt%process_instance)) then
        ! this branch only for unit test
        call evt%process_instance%get_trace &
             (evt%particle_set, i_term=1, n_incoming=evt%process%get_n_in ())
     end if
   end subroutine evt_resonance_fill_momenta
 
 @ %def evt_resonance_fill_momenta
 @
 Return the indices of those subprocesses which can be considered
 on-shell.  The result depends on the stored particle set (outgoing
 momenta) and on the on-shell limit value.
 
 The index [[evt%selected_component]] identifies the particular history set that
 corresponds to the given process component.  Recall that process
 components may have different external particles, so they have
 distinct history sets.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: determine_on_shell_histories &
        => evt_resonance_determine_on_shell_histories
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_determine_on_shell_histories &
        (evt, index_array)
     class(evt_resonance_t), intent(in) :: evt
     integer, dimension(:), allocatable, intent(out) :: index_array
     integer :: i
     i = evt%selected_component
     call evt%res_history_set(i)%determine_on_shell_histories &
          (evt%particle_set%get_outgoing_momenta (), &
          evt%on_shell_limit, &
          index_array)
   end subroutine evt_resonance_determine_on_shell_histories
     
 @ %def evt_resonance_determine_on_shell_histories
 @ Evaluate selected subprocesses.  (In actual operation, the ones that
 have been tagged as on-shell.)
 
 We assume that the MCI, term, and channel indices for the subprocesses
 can all be set to 1.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: evaluate_subprocess => evt_resonance_evaluate_subprocess
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_evaluate_subprocess (evt, index_array)
     class(evt_resonance_t), intent(inout) :: evt
     integer, dimension(:), intent(in) :: index_array
     integer :: k, i
     if (allocated (evt%instance)) then
        do k = 1, size (index_array)
           i = index_array(k)
           associate (instance => evt%instance(i)%p)
             call instance%choose_mci (1)
             call instance%set_trace (evt%particle_set, 1, check_match=.false.)
             call instance%recover (channel = 1, i_term = 1, &
                  update_sqme = .true., recover_phs = .false.)
           end associate
        end do
     end if
   end subroutine evt_resonance_evaluate_subprocess
     
 @ %def evt_resonance_evaluate_subprocess
 @ Return the current squared matrix-element value of the master
 process, and of the selected resonant subprocesses, respectively.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: get_master_sqme => evt_resonance_get_master_sqme
   procedure :: get_subprocess_sqme => evt_resonance_get_subprocess_sqme
 <<Resonance insertion: procedures>>=
   function evt_resonance_get_master_sqme (evt) result (sqme)
     class(evt_resonance_t), intent(in) :: evt
     real(default) :: sqme
     sqme = evt%process_instance%get_sqme ()
   end function evt_resonance_get_master_sqme
   
   subroutine evt_resonance_get_subprocess_sqme (evt, sqme, index_array)
     class(evt_resonance_t), intent(in) :: evt
     real(default), dimension(:), intent(out) :: sqme
     integer, dimension(:), intent(in), optional :: index_array
     integer :: k, i
     if (present (index_array)) then
        sqme = 0
        do k = 1, size (index_array)
           call get_sqme (index_array(k))
        end do
     else
        do i = 1, size (evt%instance)
           call get_sqme (i)
        end do
     end if
   contains
     subroutine get_sqme (i)
       integer, intent(in) :: i
       associate (instance => evt%instance(i)%p)
         sqme(i) = instance%get_sqme ()
       end associate
     end subroutine get_sqme
   end subroutine evt_resonance_get_subprocess_sqme
   
 @ %def evt_resonance_get_master_sqme
 @ %def evt_resonance_get_subprocess_sqme
 @ Apply a turnoff factor for off-shell kinematics to the [[sqme]]
 values.  The [[sqme]] array indices are offset from the resonance
 history set entries.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: apply_turnoff_factor => evt_resonance_apply_turnoff_factor
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_apply_turnoff_factor (evt, sqme, index_array)
     class(evt_resonance_t), intent(in) :: evt
     real(default), dimension(:), intent(inout) :: sqme
     integer, dimension(:), intent(in) :: index_array
     integer :: k, i_res, i_prc
     do k = 1, size (index_array)
        i_res = evt%selected_component
        i_prc = index_array(k) + evt%index_offset(i_res)
        sqme(i_prc) = sqme(i_prc) &
             * evt%res_history_set(i_res)%evaluate_gaussian &
             &   (evt%particle_set%get_outgoing_momenta (), &
             &    evt%on_shell_turnoff, index_array(k))
     end do
   end subroutine evt_resonance_apply_turnoff_factor
   
 @ %def evt_resonance_apply_turnoff_factor
 @ We use the calculations of resonant matrix elements to determine
 probabilities for all applicable resonance configurations.  This method combines
 the steps implemented above.  
 
 First, we determine the selected process component.
 
 TODO: the version below selects the first component which is found
 active.  This make sense only for standard LO process components,
 where exactly one component corresponds to a MCI set.
 
 For the selected process component, we query the kinematics and
 determine the applicable resonance histories.  We collect squared
 matrix elements for those resonance histories and compare them to the
 master-process squared matrix element.
 
 The result is the probability for each resonance history
 together with the probability for non-resonant background (zeroth
 entry).  The latter is defined as the difference between the complete
 process result and the sum of the resonances, ignoring the possibility
 for interference.  If the complete process result is actually
 undershooting the sum of resonances, we nevertheless count the
 background with positive probability.
 
 When looking up the subprocess sqme, we must add the [[index_offset]]
 to the resulting array, since the indices returned by the individual
 history set all count from one, while the subprocess instances that
 belong to process components are collected in one flat array.
 
 After determining matrix elements and background, we may reduce the
 weight of the matrix elements in the selector by applying a turnoff
 factor.
 
 The factor [[background_factor]] indicates whether to include the background
 contribution at all, as long as there is a nonvanishing resonance
 contribution.  Note that instead of setting background to zero, we just
 multiply it by a very small number.  This ensures that indices are assigned
 correctly, and that background will eventually be selected if smooth turnoff
 is chosen.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: compute_probabilities => evt_resonance_compute_probabilities
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_compute_probabilities (evt)
     class(evt_resonance_t), intent(inout) :: evt
     integer, dimension(:), allocatable :: index_array
     real(default) :: sqme_master, sqme_sum, sqme_bg
     real(default), dimension(:), allocatable :: sqme_res
     integer :: n, ic
     if (.not. associated (evt%process_instance))  return
     n = size (evt%instance)
     call evt%select_component (0)
     FIND_ACTIVE_COMPONENT: do ic = 1, evt%process%get_n_components ()
        if (evt%process%component_is_selected (ic)) then
           call evt%select_component (ic)
           exit FIND_ACTIVE_COMPONENT
        end if
     end do FIND_ACTIVE_COMPONENT
     if (evt%selected_component > 0) then
        call evt%determine_on_shell_histories (index_array)
     else
        allocate (index_array (0))
     end if
     call evt%evaluate_subprocess &
          (index_array + evt%index_offset(evt%selected_component))
     allocate (sqme_res (n), source = 0._default)
     call evt%get_subprocess_sqme &
          (sqme_res, index_array + evt%index_offset(evt%selected_component))
     sqme_master = evt%get_master_sqme ()
     sqme_sum = sum (sqme_res)
     sqme_bg = abs (sqme_master - sqme_sum)
     if (evt%on_shell_turnoff > 0) then
        call evt%apply_turnoff_factor (sqme_res, index_array)
     end if
     if (any (sqme_res > 0)) then
        sqme_bg = sqme_bg * evt%background_factor
     end if
     call evt%init_selector ([sqme_bg, sqme_res], offset = -1)
   end subroutine evt_resonance_compute_probabilities
     
 @ %def evt_resonance_compute_probabilities
 @ Set the selected component (unit tests).
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: select_component => evt_resonance_select_component
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_select_component (evt, i_component)
     class(evt_resonance_t), intent(inout) :: evt
     integer, intent(in) :: i_component
     evt%selected_component = i_component
   end subroutine evt_resonance_select_component
   
 @ %def evt_resonance_select_component
 @ 
 \subsection{Sanity check}
 Check the color assignment, which may be wrong for the inserted resonances.
 Delegated to the particle-set component.  Return offending particle
 indices and, optionally, particles as arrays.
 
 This is done in a unit test.  The current algorithm, i.e., selecting
 the color assignment from the resonant-subprocess instance, should not
 generate invalid color assignments.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: find_prt_invalid_color => evt_resonance_find_prt_invalid_color
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_find_prt_invalid_color (evt, index, prt)
     class(evt_resonance_t), intent(in) :: evt
     integer, dimension(:), allocatable, intent(out) :: index
     type(particle_t), dimension(:), allocatable, intent(out), optional :: prt
     if (evt%particle_set_exists) then
        call evt%particle_set%find_prt_invalid_color (index, prt)
     else
        allocate (prt (0))
     end if
   end subroutine evt_resonance_find_prt_invalid_color
   
 @ %def evt_resonance_find_prt_invalid_color
 @
 \subsection{API implementation}
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: prepare_new_event => evt_resonance_prepare_new_event
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_prepare_new_event (evt, i_mci, i_term)
     class(evt_resonance_t), intent(inout) :: evt
     integer, intent(in) :: i_mci, i_term
     call evt%reset ()
   end subroutine evt_resonance_prepare_new_event
 
 @ %def evt_resonance_prepare_new_event
 @ Select one of the histories, based on the momentum array from the
 current particle set.  Compute the probabilities for all resonant
 subprocesses and initialize the selector accordingly.  Then select one
 resonance history, or none.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: generate_weighted => evt_resonance_generate_weighted
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_generate_weighted (evt, probability)
     class(evt_resonance_t), intent(inout) :: evt
     real(default), intent(inout) :: probability
     call evt%fill_momenta ()
     call evt%compute_probabilities ()
     call evt%selector%generate (evt%rng, evt%selected_history)
     probability = 1
   end subroutine evt_resonance_generate_weighted
 
 @ %def evt_resonance_generate_weighted
 @ Here take the current particle set and insert resonance intermediate
 states if applicable.  The resonance history has already been chosen
 by the generator above.  If no resonance history applies, just retain
 the particle set.
 
 If a resonance history applies, we factorize the exclusive interaction
 of the selected (resonance-process) process instance.  With a
 temporary particle set [[prt_set]] as workspace, we the insert the
 resonances, reinstate parent-child relations and set colors and
 momenta for the resonances.  The temporary is then copied back.
 
 Taking the event data from the resonant subprocess instead of the
 master process, guarantees that all flavor, helicity, and color
 assignments are valid for the selected resonance history.  Note that
 the transform may thus choose a quantum-number combination that is
 different from the one chosen by the master process.
 
 The [[i_term]] value for the selected subprocess instance is always
 1.  We support only LO process.  For those, the master process may
 have several terms (= components) that correspond to different
 external states.  The subprocesses are distinct, each one corresponds
 to a definite master component, and by itself it consists of a single
 component/term.
 
 However, if the selector chooses resonance history \#0, i.e., no
 resonance, we just copy the particle set from the previous (i.e.,
 trivial) event transform and ignore all subprocess data.
 <<Resonance insertion: evt resonance: TBP>>=
   procedure :: make_particle_set => evt_resonance_make_particle_set
 <<Resonance insertion: procedures>>=
   subroutine evt_resonance_make_particle_set &
        (evt, factorization_mode, keep_correlations, r)
     class(evt_resonance_t), intent(inout) :: evt
     integer, intent(in) :: factorization_mode
     logical, intent(in) :: keep_correlations
     real(default), dimension(:), intent(in), optional :: r
     type(particle_set_t), target :: prt_set
     type(particle_t), dimension(:), allocatable :: prt
     integer :: n_beam, n_in, n_vir, n_res, n_out, i, i_res, i_term, i_tree
     type(interaction_t), pointer :: int_matrix, int_flows
     integer, dimension(:), allocatable :: map
     type(resonance_tree_t) :: res_tree
     if (associated (evt%previous)) then
        if (evt%previous%particle_set_exists) then
           if (evt%selected_history > 0) then
              if (allocated (evt%instance)) then
                 associate (instance => evt%instance(evt%selected_history)%p)
                   call instance%evaluate_event_data (weight = 1._default)
                   i_term = 1
                   int_matrix => instance%get_matrix_int_ptr (i_term)
                   int_flows  => instance%get_flows_int_ptr (i_term)
                   call evt%factorize_interactions (int_matrix, int_flows, &
                        factorization_mode, keep_correlations, r)
                   call evt%tag_incoming ()
                 end associate
              else  ! this branch only for unit test
                 evt%particle_set = evt%previous%particle_set
              end if
              i_tree = evt%selected_history &
                   - evt%index_offset(evt%selected_component)
              call evt%res_history_set(evt%selected_component)%get_tree &
                   (i_tree, res_tree)
              n_beam = evt%particle_set%get_n_beam ()
              n_in = evt%particle_set%get_n_in ()
              n_vir = evt%particle_set%get_n_vir ()
              n_out = evt%particle_set%get_n_out ()
              n_res = res_tree%get_n_resonances ()
              allocate (map (n_beam + n_in + n_vir + n_out))
              map(1:n_beam+n_in+n_vir) &
                   = [(i, i = 1, n_beam+n_in+n_vir)]
              map(n_beam+n_in+n_vir+1:n_beam+n_in+n_vir+n_out) &
                   = [(i + n_res, &
                   &   i = n_beam+n_in+n_vir+1, &
                   &       n_beam+n_in+n_vir+n_out)]
              call prt_set%transfer (evt%particle_set, n_res, map)
              do i = 1, n_res
                 i_res = n_beam + n_in + n_vir + i
                 call prt_set%insert (i_res, &
                      PRT_RESONANT, &
                      res_tree%get_flv (i), &
                      res_tree%get_children (i, &
                      &   n_beam+n_in+n_vir, n_beam+n_in+n_vir+n_res))
              end do
              do i = n_res, 1, -1
                 i_res = n_beam + n_in + n_vir + i
                 call prt_set%recover_color (i_res)
              end do
              call prt_set%set_momentum &
                   (map(:), evt%particle_set%get_momenta (), on_shell = .true.)
              do i = n_res, 1, -1
                 i_res = n_beam + n_in + n_vir + i
                 call prt_set%recover_momentum (i_res)
              end do
              call evt%particle_set%final ()
              evt%particle_set = prt_set
              call prt_set%final ()
              evt%particle_set_exists = .true.
           else  ! retain particle set, as copied from previous evt
              evt%particle_set_exists = .true.
           end if
        else
           evt%particle_set_exists = .false.
        end if
     else
        evt%particle_set_exists = .false.
     end if
   end subroutine evt_resonance_make_particle_set
 
 @ %def event_resonance_make_particle_set
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[resonance_insertion_ut.f90]]>>=
 <<File header>>
 
 module resonance_insertion_ut
   use unit_tests
   use resonance_insertion_uti
 
 <<Standard module head>>
 
 <<Resonance insertion: public test>>
 
 contains
 
 <<Resonance insertion: test driver>>
 
 end module resonance_insertion_ut
 @ %def resonance_insertion_ut
 @
 <<[[resonance_insertion_uti.f90]]>>=
 <<File header>>
 
 module resonance_insertion_uti
 
 <<Use kinds>>
 <<Use strings>>
   use format_utils, only: write_separator
   use os_interface
   use lorentz
   use rng_base, only: rng_t
   use flavors, only: flavor_t
   use colors, only: color_t
   use models, only: syntax_model_file_init, syntax_model_file_final
   use models, only: model_list_t, model_t
   use particles, only: particle_t, particle_set_t
 
   use resonances, only: resonance_info_t
   use resonances, only: resonance_history_t
   use resonances, only: resonance_history_set_t
 
   use event_transforms
   use resonance_insertion
 
   use rng_base_ut, only: rng_test_t
 
 <<Standard module head>>
 
 <<Resonance insertion: test declarations>>
 
 contains
 
 <<Resonance insertion: tests>>
 
 end module resonance_insertion_uti
 
 @ %def resonance_insertion_uti
 @ API: driver for the unit tests below.
 <<Resonance insertion: public test>>=
   public :: resonance_insertion_test
 <<Resonance insertion: test driver>>=
   subroutine resonance_insertion_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Resonance insertion: execute tests>>
   end subroutine resonance_insertion_test
 
 @ %def resonance_insertion_test
 @
 \subsubsection{Test resonance insertion as event transform}
 Insert a resonance (W boson) into an event with momentum assignment.
 <<Resonance insertion: execute tests>>=
   call test (resonance_insertion_1, "resonance_insertion_1", &
        "simple resonance insertion", &
        u, results)
 <<Resonance insertion: test declarations>>=
   public :: resonance_insertion_1
 <<Resonance insertion: tests>>=
   subroutine resonance_insertion_1 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(particle_set_t) :: pset
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(resonance_info_t) :: res_info
     type(resonance_history_t) :: res_history
     type(resonance_history_set_t), dimension(1) :: res_history_set
     type(evt_trivial_t), target :: evt_trivial
     type(evt_resonance_t), target :: evt_resonance
     type(flavor_t) :: fw
     type(color_t) :: col
     real(default) :: mw, ew, pw
     type(vector4_t), dimension(5) :: p
     class(rng_t), allocatable :: rng
     real(default) :: probability
     integer, dimension(:), allocatable :: i_invalid
     type(particle_t), dimension(:), allocatable :: prt_invalid
     integer :: i
 
     write (u, "(A)")  "* Test output: resonance_insertion_1"
     write (u, "(A)")  "*   Purpose: apply simple resonance insertion"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM"), var_str ("SM.mdl"), &
          os_data, model)
     ! reset slightly in order to avoid a rounding ambiguity
     call model%set_real (var_str ("mW"), 80.418_default)
 
     write (u, "(A)")  "* Initialize particle set"
     write (u, "(A)")
     
     call pset%init_direct (n_beam = 0, n_in = 2, n_rem = 0, n_vir = 0, n_out = 3, &
          pdg = [1, -1, 1, -2, 24], model = model)
 
     call fw%init (24, model)
 
     mw = fw%get_mass ()
     ew = 200._default
     pw = sqrt (ew**2 - mw**2)
 
     p(1) = vector4_moving (ew, ew, 3)
     p(2) = vector4_moving (ew,-ew, 3)
     p(3) = vector4_moving (ew/2, vector3_moving ([pw/2, mw/2, 0._default]))
     p(4) = vector4_moving (ew/2, vector3_moving ([pw/2,-mw/2, 0._default]))
     p(5) = vector4_moving (ew, vector3_moving ([-pw, 0._default, 0._default]))
 
     call pset%set_momentum (p, on_shell = .true.)
     
     call col%init_col_acl (1,0)
     call pset%set_color (1, col)
     
     call col%init_col_acl (0,1)
     call pset%set_color (2, col)
 
     call col%init_col_acl (2,0)
     call pset%set_color (3, col)
     
     call col%init_col_acl (0,2)
     call pset%set_color (4, col)
 
     call col%init_col_acl (0,0)
     call pset%set_color (5, col)
 
     write (u, "(A)")  "* Fill trivial event transform"
     write (u, "(A)")
 
     call evt_trivial%reset ()
     call evt_trivial%set_particle_set (pset, 1, 1)
     call evt_trivial%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Prepare resonance history set"
     write (u, "(A)")
     
     call res_history_set(1)%init ()
 
     call res_info%init (3, -24, model, 2)
     call res_history%add_resonance (res_info)
     call res_history_set(1)%enter (res_history)
     call res_history%clear ()
 
     call res_history_set(1)%freeze ()
 
     write (u, "(A)")  "* Initialize resonance insertion transform"
     write (u, "(A)")
     
     evt_trivial%next => evt_resonance
     evt_resonance%previous => evt_trivial
     
     allocate (rng_test_t :: rng)
     call evt_resonance%import_rng (rng)
 
     call evt_resonance%set_resonance_data (res_history_set)
     call evt_resonance%select_component (1)
     call evt_resonance%write (u)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill resonance insertion transform"
     write (u, "(A)")
     
     call evt_resonance%prepare_new_event (1, 1)
     call evt_resonance%init_selector ([1._default])
     call evt_resonance%generate_weighted (probability)
     call evt_resonance%make_particle_set (0, .false.)
     
     call evt_resonance%write (u)
     
     write (u, "(A)")
     write (u, "(A,1x,F8.5)")  "Event probability =", probability
 
     write (u, "(A)")
     call evt_resonance%find_prt_invalid_color (i_invalid, prt_invalid)
     write (u, "(A)")  "Particles with invalid color:"
     select case (size (prt_invalid))
     case (0)
        write (u, "(2x,A)")  "[none]"
     case default
        do i = 1, size (prt_invalid)
           write (u, "(1x,A,1x,I0)", advance="no")  "Particle", i_invalid(i)
           call prt_invalid(i)%write (u)
        end do
     end select
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_resonance%final ()
     call evt_trivial%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: resonance_insertion_1"
 
   end subroutine resonance_insertion_1
 
 @ %def resonance_insertion_1
 @
 \subsubsection{Resonance insertion with color mismatch}
 Same as previous test (but no momenta); resonance insertion should fail
 because of color mismatch: W boson is color-neutral.
 <<Resonance insertion: execute tests>>=
   call test (resonance_insertion_2, "resonance_insertion_2", &
        "resonance color mismatch", &
        u, results)
 <<Resonance insertion: test declarations>>=
   public :: resonance_insertion_2
 <<Resonance insertion: tests>>=
   subroutine resonance_insertion_2 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(particle_set_t) :: pset
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(resonance_info_t) :: res_info
     type(resonance_history_t) :: res_history
     type(resonance_history_set_t), dimension(1) :: res_history_set
     type(evt_trivial_t), target :: evt_trivial
     type(evt_resonance_t), target :: evt_resonance
     type(color_t) :: col
     class(rng_t), allocatable :: rng
     real(default) :: probability
     type(particle_t), dimension(:), allocatable :: prt_invalid
     integer, dimension(:), allocatable :: i_invalid
     integer :: i
 
     write (u, "(A)")  "* Test output: resonance_insertion_2"
     write (u, "(A)")  "*   Purpose: resonance insertion with color mismatch"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM"), var_str ("SM.mdl"), &
          os_data, model)
 
     write (u, "(A)")  "* Initialize particle set"
     write (u, "(A)")
     
     call pset%init_direct (n_beam = 0, n_in = 2, n_rem = 0, n_vir = 0, n_out = 3, &
          pdg = [1, -1, 1, -2, 24], model = model)
 
     call col%init_col_acl (1,0)
     call pset%set_color (1, col)
     
     call col%init_col_acl (0,2)
     call pset%set_color (2, col)
 
     call col%init_col_acl (1,0)
     call pset%set_color (3, col)
     
     call col%init_col_acl (0,2)
     call pset%set_color (4, col)
 
     call col%init_col_acl (0,0)
     call pset%set_color (5, col)
 
     write (u, "(A)")  "* Fill trivial event transform"
     write (u, "(A)")
 
     call evt_trivial%reset ()
     call evt_trivial%set_particle_set (pset, 1, 1)
     call evt_trivial%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Prepare resonance history set"
     write (u, "(A)")
     
     call res_history_set(1)%init ()
 
     call res_info%init (3, -24, model, 2)
     call res_history%add_resonance (res_info)
     call res_history_set(1)%enter (res_history)
     call res_history%clear ()
 
     call res_history_set(1)%freeze ()
 
     write (u, "(A)")  "* Initialize resonance insertion transform"
     write (u, "(A)")
     
     evt_trivial%next => evt_resonance
     evt_resonance%previous => evt_trivial
     
     allocate (rng_test_t :: rng)
     call evt_resonance%import_rng (rng)
 
     call evt_resonance%set_resonance_data (res_history_set)
     call evt_resonance%select_component (1)
     call evt_resonance%write (u)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill resonance insertion transform"
     write (u, "(A)")
     
     call evt_resonance%prepare_new_event (1, 1)
     call evt_resonance%init_selector ([1._default])
     call evt_resonance%generate_weighted (probability)
     call evt_resonance%make_particle_set (0, .false.)
     
     call evt_resonance%write (u)
     
     write (u, "(A)")
     write (u, "(A,1x,F8.5)")  "Event probability =", probability
 
     write (u, "(A)")
     call evt_resonance%find_prt_invalid_color (i_invalid, prt_invalid)
     write (u, "(A)")  "Particles with invalid color:"
     select case (size (prt_invalid))
     case (0)
        write (u, "(2x,A)")  "[none]"
     case default
        do i = 1, size (prt_invalid)
           write (u, "(1x,A,1x,I0)", advance="no")  "Particle", i_invalid(i)
           call prt_invalid(i)%write (u)
        end do
     end select
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_resonance%final ()
     call evt_trivial%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: resonance_insertion_2"
 
   end subroutine resonance_insertion_2
 
 @ %def resonance_insertion_2
 @
 \subsubsection{Complex resonance history}
 This is the resonance history $u\bar u \to (t\to W^+ b) + (\bar t\to
 (h \to b\bar b) + (\bar t^\ast \to W^-\bar b))$.
 <<Resonance insertion: execute tests>>=
   call test (resonance_insertion_3, "resonance_insertion_3", &
        "complex resonance history", &
        u, results)
 <<Resonance insertion: test declarations>>=
   public :: resonance_insertion_3
 <<Resonance insertion: tests>>=
   subroutine resonance_insertion_3 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(particle_set_t) :: pset
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(resonance_info_t) :: res_info
     type(resonance_history_t) :: res_history
     type(resonance_history_set_t), dimension(1) :: res_history_set
     type(evt_trivial_t), target :: evt_trivial
     type(evt_resonance_t), target :: evt_resonance
     type(color_t) :: col
     class(rng_t), allocatable :: rng
     real(default) :: probability
     type(particle_t), dimension(:), allocatable :: prt_invalid
     integer, dimension(:), allocatable :: i_invalid
     integer :: i
 
     write (u, "(A)")  "* Test output: resonance_insertion_3"
     write (u, "(A)")  "*   Purpose: resonance insertion with color mismatch"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM"), var_str ("SM.mdl"), &
          os_data, model)
 
     write (u, "(A)")  "* Initialize particle set"
     write (u, "(A)")
     
     call pset%init_direct (n_beam = 0, n_in = 2, n_rem = 0, n_vir = 0, n_out = 6, &
          pdg = [2, -2, 24, 5, 5, -5, -24, -5], model = model)
 
     call col%init_col_acl (1,0)
     call pset%set_color (1, col)
     
     call col%init_col_acl (0,2)
     call pset%set_color (2, col)
 
     call col%init_col_acl (0,0)
     call pset%set_color (3, col)
     
     call col%init_col_acl (1,0)
     call pset%set_color (4, col)
 
     call col%init_col_acl (3,0)
     call pset%set_color (5, col)
 
     call col%init_col_acl (0,3)
     call pset%set_color (6, col)
 
     call col%init_col_acl (0,0)
     call pset%set_color (7, col)
 
     call col%init_col_acl (0,2)
     call pset%set_color (8, col)
 
     write (u, "(A)")  "* Fill trivial event transform"
     write (u, "(A)")
 
     call evt_trivial%reset ()
     call evt_trivial%set_particle_set (pset, 1, 1)
     call evt_trivial%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Prepare resonance history set"
     write (u, "(A)")
     
     call res_history_set(1)%init ()
 
     call res_info%init (3, 6, model, 6)
     call res_history%add_resonance (res_info)
     call res_info%init (12, 25, model, 6)
     call res_history%add_resonance (res_info)
     call res_info%init (60, -6, model, 6)
     call res_history%add_resonance (res_info)
     call res_history_set(1)%enter (res_history)
     call res_history%clear ()
 
     call res_history_set(1)%freeze ()
 
     write (u, "(A)")  "* Initialize resonance insertion transform"
     write (u, "(A)")
     
     evt_trivial%next => evt_resonance
     evt_resonance%previous => evt_trivial
     
     allocate (rng_test_t :: rng)
     call evt_resonance%import_rng (rng)
 
     call evt_resonance%set_resonance_data (res_history_set)
     call evt_resonance%select_component (1)
     call evt_resonance%write (u)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill resonance insertion transform"
     write (u, "(A)")
     
     call evt_resonance%prepare_new_event (1, 1)
     call evt_resonance%init_selector ([1._default])
     call evt_resonance%generate_weighted (probability)
     call evt_resonance%make_particle_set (0, .false.)
     
     call evt_resonance%write (u)
     
     write (u, "(A)")
     call evt_resonance%find_prt_invalid_color (i_invalid, prt_invalid)
     write (u, "(A)")  "Particles with invalid color:"
     select case (size (prt_invalid))
     case (0)
        write (u, "(2x,A)")  "[none]"
     case default
        do i = 1, size (prt_invalid)
           write (u, "(1x,A,1x,I0)", advance="no")  "Particle", i_invalid(i)
           call prt_invalid(i)%write (u)
        end do
     end select
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_resonance%final ()
     call evt_trivial%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: resonance_insertion_3"
 
   end subroutine resonance_insertion_3
 
 @ %def resonance_insertion_3
 @
 \subsubsection{Resonance history selection}
 Another test with zero momenta: select one of several resonant channels
 using the selector component.
 <<Resonance insertion: execute tests>>=
   call test (resonance_insertion_4, "resonance_insertion_4", &
        "resonance history selection", &
        u, results)
 <<Resonance insertion: test declarations>>=
   public :: resonance_insertion_4
 <<Resonance insertion: tests>>=
   subroutine resonance_insertion_4 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(particle_set_t) :: pset
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(resonance_info_t) :: res_info
     type(resonance_history_t) :: res_history
     type(resonance_history_set_t), dimension(1) :: res_history_set
     type(evt_trivial_t), target :: evt_trivial
     type(evt_resonance_t), target :: evt_resonance
     type(color_t) :: col
     class(rng_t), allocatable :: rng
     real(default) :: probability
     integer :: i
 
     write (u, "(A)")  "* Test output: resonance_insertion_4"
     write (u, "(A)")  "*   Purpose: resonance history selection"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM"), var_str ("SM.mdl"), &
          os_data, model)
 
     write (u, "(A)")  "* Initialize particle set"
     write (u, "(A)")
     
     call pset%init_direct (n_beam = 0, n_in = 2, n_rem = 0, n_vir = 0, n_out = 4, &
          pdg = [1, -1, 1, -2, -3, 4], model = model)
 
     write (u, "(A)")  "* Fill trivial event transform"
     write (u, "(A)")
 
     call evt_trivial%reset ()
     call evt_trivial%set_particle_set (pset, 1, 1)
     call evt_trivial%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Prepare resonance history set"
     write (u, "(A)")
     
     call res_history_set(1)%init ()
 
     call res_info%init (3, -24, model, 4)
     call res_history%add_resonance (res_info)
     call res_history_set(1)%enter (res_history)
     call res_history%clear ()
 
     call res_info%init (12, 24, model, 4)
     call res_history%add_resonance (res_info)
     call res_history_set(1)%enter (res_history)
     call res_history%clear ()
 
     call res_info%init (12, 24, model, 4)
     call res_history%add_resonance (res_info)
     call res_info%init (15, 25, model, 4)
     call res_history%add_resonance (res_info)
     call res_history_set(1)%enter (res_history)
     call res_history%clear ()
 
     call res_history_set(1)%freeze ()
 
     write (u, "(A)")  "* Initialize resonance insertion transform"
     write (u, "(A)")
     
     evt_trivial%next => evt_resonance
     evt_resonance%previous => evt_trivial
     
     allocate (rng_test_t :: rng)
     call evt_resonance%import_rng (rng)
 
     call evt_resonance%set_resonance_data (res_history_set)
     call evt_resonance%select_component (1)
     call evt_resonance%write (u)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill resonance insertion transform"
     write (u, "(A)")
     
     do i = 1, 6
        write (u, "(A,1x,I0)")  "* Event #", i
        write (u, "(A)")
     
        call evt_resonance%prepare_new_event (1, 1)
        call evt_resonance%init_selector ([1._default, 2._default, 1._default])
        call evt_resonance%generate_weighted (probability)
        call evt_resonance%make_particle_set (0, .false.)
     
        call evt_resonance%write (u)
        write (u, "(A)")
     end do
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_resonance%final ()
     call evt_trivial%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: resonance_insertion_4"
 
   end subroutine resonance_insertion_4
 
 @ %def resonance_insertion_4
 @
 \subsubsection{Resonance history selection}
 Another test with zero momenta: select either a resonant channel or no
 resonance.
 <<Resonance insertion: execute tests>>=
   call test (resonance_insertion_5, "resonance_insertion_5", &
        "resonance history on/off", &
        u, results)
 <<Resonance insertion: test declarations>>=
   public :: resonance_insertion_5
 <<Resonance insertion: tests>>=
   subroutine resonance_insertion_5 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(particle_set_t) :: pset
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(resonance_info_t) :: res_info
     type(resonance_history_t) :: res_history
     type(resonance_history_set_t), dimension(1) :: res_history_set
     type(evt_trivial_t), target :: evt_trivial
     type(evt_resonance_t), target :: evt_resonance
     type(color_t) :: col
     class(rng_t), allocatable :: rng
     real(default) :: probability
     integer :: i
 
     write (u, "(A)")  "* Test output: resonance_insertion_5"
     write (u, "(A)")  "*   Purpose: resonance history selection including no resonance"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM"), var_str ("SM.mdl"), &
          os_data, model)
 
     write (u, "(A)")  "* Initialize particle set"
     write (u, "(A)")
     
     call pset%init_direct (n_beam = 0, n_in = 2, n_rem = 0, n_vir = 0, n_out = 4, &
          pdg = [1, -1, 1, -2, -3, 4], model = model)
 
     write (u, "(A)")  "* Fill trivial event transform"
     write (u, "(A)")
 
     call evt_trivial%reset ()
     call evt_trivial%set_particle_set (pset, 1, 1)
 
     write (u, "(A)")  "* Prepare resonance history set"
     write (u, "(A)")
     
     call res_history_set(1)%init ()
 
     call res_info%init (3, -24, model, 4)
     call res_history%add_resonance (res_info)
     call res_history_set(1)%enter (res_history)
     call res_history%clear ()
 
     call res_history_set(1)%freeze ()
 
     write (u, "(A)")  "* Initialize resonance insertion transform"
     write (u, "(A)")
     
     evt_trivial%next => evt_resonance
     evt_resonance%previous => evt_trivial
     
     allocate (rng_test_t :: rng)
     call evt_resonance%import_rng (rng)
 
     call evt_resonance%set_resonance_data (res_history_set)
     call evt_resonance%select_component (1)
     
     write (u, "(A)")  "* Fill resonance insertion transform"
     write (u, "(A)")
     
     do i = 1, 2
        write (u, "(A,1x,I0)")  "* Event #", i
        write (u, "(A)")
     
        call evt_resonance%prepare_new_event (1, 1)
        call evt_resonance%init_selector ([1._default, 3._default], offset = -1)
        call evt_resonance%generate_weighted (probability)
        call evt_resonance%make_particle_set (0, .false.)
     
        call evt_resonance%write (u)
        write (u, "(A)")
     end do
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_resonance%final ()
     call evt_trivial%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: resonance_insertion_5"
 
   end subroutine resonance_insertion_5
 
 @ %def resonance_insertion_5
 @
 \subsubsection{Resonance insertion with structured beams}
 Insert a resonance (W boson) into an event with beam and virtual
 particles.
 <<Resonance insertion: execute tests>>=
   call test (resonance_insertion_6, "resonance_insertion_6", &
        "resonance insertion with beam structure", &
        u, results)
 <<Resonance insertion: test declarations>>=
   public :: resonance_insertion_6
 <<Resonance insertion: tests>>=
   subroutine resonance_insertion_6 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(model_list_t) :: model_list
     type(particle_set_t) :: pset
     type(model_t), pointer :: model
     type(resonance_info_t) :: res_info
     type(resonance_history_t) :: res_history
     type(resonance_history_set_t), dimension(1) :: res_history_set
     type(evt_trivial_t), target :: evt_trivial
     type(evt_resonance_t), target :: evt_resonance
     class(rng_t), allocatable :: rng
     real(default) :: probability
 
     write (u, "(A)")  "* Test output: resonance_insertion_6"
     write (u, "(A)")  "*   Purpose: resonance insertion with structured beams"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM"), var_str ("SM.mdl"), &
          os_data, model)
 
     write (u, "(A)")  "* Initialize particle set"
     write (u, "(A)")
     
     call pset%init_direct (n_beam = 2, n_in = 2, n_rem = 2, n_vir = 0, n_out = 2, &
          pdg = [11, -11, 11, -11, 22, 22, 13, -13], model = model)
 
     write (u, "(A)")  "* Fill trivial event transform"
     write (u, "(A)")
 
     call evt_trivial%reset ()
     call evt_trivial%set_particle_set (pset, 1, 1)
     call evt_trivial%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Prepare resonance history set"
     write (u, "(A)")
     
     call res_history_set(1)%init ()
 
     call res_info%init (3, 23, model, 2)
     call res_history%add_resonance (res_info)
     call res_history_set(1)%enter (res_history)
     call res_history%clear ()
 
     call res_history_set(1)%freeze ()
 
     write (u, "(A)")  "* Initialize resonance insertion transform"
     write (u, "(A)")
     
     evt_trivial%next => evt_resonance
     evt_resonance%previous => evt_trivial
     
     allocate (rng_test_t :: rng)
     call evt_resonance%import_rng (rng)
 
     call evt_resonance%set_resonance_data (res_history_set)
     call evt_resonance%select_component (1)
     call evt_resonance%write (u)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill resonance insertion transform"
     write (u, "(A)")
     
     call evt_resonance%prepare_new_event (1, 1)
     call evt_resonance%init_selector ([1._default])
     call evt_resonance%generate_weighted (probability)
     call evt_resonance%make_particle_set (0, .false.)
     
     call evt_resonance%write (u)
     
     write (u, "(A)")
     write (u, "(A,1x,F8.5)")  "Event probability =", probability
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_resonance%final ()
     call evt_trivial%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: resonance_insertion_6"
 
   end subroutine resonance_insertion_6
 
 @ %def resonance_insertion_6
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Recoil kinematics}
 <<[[recoil_kinematics.f90]]>>=
 <<File header>>
 
 module recoil_kinematics
 
 <<Use kinds>>
   use constants, only: twopi
   use lorentz, only: vector4_t
   use lorentz, only: vector4_moving
   use lorentz, only: vector3_moving
   use lorentz, only: transverse_part
   use lorentz, only: lorentz_transformation_t
   use lorentz, only: inverse
   use lorentz, only: boost
   use lorentz, only: transformation
   use lorentz, only: operator(+)
   use lorentz, only: operator(-)
   use lorentz, only: operator(*)
   use lorentz, only: operator(**)
 
 <<Standard module head>>
 
 <<Recoil kinematics: public>>
 
 <<Recoil kinematics: parameters>>
 
 <<Recoil kinematics: types>>
 
 contains
 
 <<Recoil kinematics: procedures>>
 
 end module recoil_kinematics
 @ %def recoil_kinematics
 @ 
 \subsection{$\phi$ sampler}
 This is trivial.  Generate an azimuthal angle, given a $(0,1)$ RNG parameter.
 <<Recoil kinematics: procedures>>=
   elemental subroutine generate_phi_recoil (r, phi)
     real(default), intent(in) :: r
     real(default), intent(out) :: phi
 
     phi = r * twopi
 
   end subroutine generate_phi_recoil
   
 @ %def generate_phi_recoil
 @
 \subsection{$Q^2$ sampler}
 The dynamics of factorization suggests to generate a flat $Q^2$
 distribution from a (random) number, event by event.   
 
 At the lowest momentum transfer values, the particle (electron) mass
 sets a smooth cutoff.  The formula can produce $Q$ values below the
 electron mass, down to zero, but with a power distribution that
 eventually evolves into the expected logarithmic distribution for $Q^2 >
 m^2$.
 
 We are talking about the absolute value here, so all $Q^2$
 values are positive.  For the actual momentum transfer, $q^2=-Q^2$.
 <<Recoil kinematics: public>>=
   public :: generate_q2_recoil
 <<Recoil kinematics: procedures>>=
   elemental subroutine generate_q2_recoil (s, x_bar, q2_max, m2, r, q2)
     real(default), intent(in) :: s
     real(default), intent(in) :: q2_max
     real(default), intent(in) :: x_bar
     real(default), intent(in) :: m2
     real(default), intent(in) :: r
     real(default), intent(out) :: q2
 
     real(default) :: q2_max_evt
 
     q2_max_evt = q2_max_event (s, x_bar, q2_max)
     
     q2 = m2 * (exp (r * log (1 + (q2_max_evt / m2))) - 1)
 
   end subroutine generate_q2_recoil
   
 @ %def generate_q_recoil
 @ 
 The $Q$ distribution is cut off from above by the kinematic limit,
 which depends on the energy that is available for the radiated photon,
 or by a user-defined cutoff -- whichever is less.  The kinematic limit
 fits the formulas for recoil momenta (see below), and it also
 implicitly enters the ISR collinear structure function, so the
 normalization of the distribution should be correct.
 <<Recoil kinematics: procedures>>=
   elemental function q2_max_event (s, x_bar, q2_max) result (q2)
     real(default), intent(in) :: s
     real(default), intent(in) :: x_bar
     real(default), intent(in) :: q2_max
     real(default) :: q2
     
     q2 = min (x_bar * s, q2_max)
     
   end function q2_max_event
     
 @ %def q2_max_event
 @
 \subsection{Kinematics functions}
 Given values for energies, $Q_{1,2}^2$, azimuthal angle, compute the
 matching polar angle of the radiating particle.  The subroutine
 returns $\sin\theta$ and $\cos\theta$.
 <<Recoil kinematics: procedures>>=
   subroutine polar_angles (s, xb, rho, ee, q2, sin_th, cos_th, ok)
     real(default), intent(in) :: s
     real(default), intent(in) :: xb
     real(default), intent(in) :: rho
     real(default), dimension(2), intent(in) :: ee
     real(default), dimension(2), intent(in) :: q2
     real(default), dimension(2), intent(out) :: sin_th
     real(default), dimension(2), intent(out) :: cos_th
     logical, intent(out) :: ok
 
     real(default), dimension(2) :: sin2_th_2
 
     sin2_th_2 = q2 / (ee * rho * xb * s)
     
     if (all (sin2_th_2 <= 1)) then
        sin_th = 2 * sqrt (sin2_th_2 * (1 - sin2_th_2))
        cos_th = 1 - 2 * sin2_th_2
        ok = .true.
     else
        sin_th = 0
        cos_th = 1
        ok = .false.
     end if
 
   end subroutine polar_angles
 
 @ %def polar_angles
 @
 Compute the acollinearity parameter $\lambda$ from azimuthal and polar
 angles.  The result is a number between $0$ and $1$.
 <<Recoil kinematics: procedures>>=
   function lambda_factor (sin_th, cos_th, cphi) result (lambda)
     real(default), dimension(2), intent(in) :: sin_th
     real(default), dimension(2), intent(in) :: cos_th
     real(default), intent(in) :: cphi
     real(default) :: lambda
 
     lambda = (1 - cos_th(1) * cos_th(2) - cphi * sin_th(1) * sin_th(2)) / 2
 
   end function lambda_factor
 
 @ %def lambda_factor
 @
 Compute the factor that rescales photon energies, such that the
 radiation angles match the kinematics parameters.
 
 For small values of $\bar x/\cosh\eta$, we have to use the Taylor
 expansion if we do not want to lose precision.  The optional argument
 allows for a unit test that compares exact and approximate.
 <<Recoil kinematics: procedures>>=
   function scale_factor (che, lambda, xb0, approximate) result (rho)
     real(default), intent(in) :: che
     real(default), intent(in) :: lambda
     real(default), intent(in) :: xb0
     logical, intent(in), optional :: approximate
     real(default) :: rho
 
     real(default), parameter :: &
          e0 = (100 * epsilon (1._default)) ** (0.3_default)
     logical :: approx
 
     if (present (approximate)) then
        approx = approximate
     else
        approx = (xb0/che) < e0
     end if
 
     if (approx) then
        rho = 1 - lambda * (xb0/(2*che)) * (1 + (1-lambda) * (xb0/che))
     else
        rho =  (che / ((1-lambda)*xb0)) &
          * (1 - sqrt (1 - 2 * (1-lambda) * (xb0/che) &
          &    + (1-lambda) * (xb0 / che)**2))
     end if
 
   end function scale_factor
 
 @ %def scale_factor
 @ The code snippet below is not used anywhere, but may be manually
 inserted in a unit test to numerically verify the approximation above.
 <<Recoil kinematics: extra test code>>=
     write (u, "(A)")
     write (u, "(A)") "*** Table: scale factor calculation"
     write (u, "(A)")
 
     lambda = 0.25_default
     write (u, FMT1)  "lambda =", lambda
     
     che = 4._default
     write (u, FMT1)  "che    =", che
     
     write (u, "(A)")  "   x0    rho(exact)   rho(approx)   rho(chosen)"
     xb0 = 1._default
     do i = 1, 30
        xb0 = xb0 / 10
        write (u, FMT4)   xb0, &
             scale_factor (che, lambda, xb0, approximate=.false.), &
             scale_factor (che, lambda, xb0, approximate=.true.), &
             scale_factor (che, lambda, xb0)
     end do
 @ 
 Compute the current values for the $x_{1,2}$ parameters, given the
 updated scale factor $\rho$ and the collinear parameters.
 <<Recoil kinematics: procedures>>=
   subroutine scaled_x (rho, ee, xb0, x, xb)
     real(default), intent(in) :: rho
     real(default), dimension(2), intent(in) :: ee
     real(default), intent(in) :: xb0
     real(default), dimension(2), intent(out) :: x
     real(default), dimension(2), intent(out) :: xb
     
     xb = rho * ee * xb0
     x = 1 - xb
 
   end subroutine scaled_x
 
 @ %def scaled_x
 @
 \subsection{Iterative solution of kinematics constraints}
 Find a solution of the kinematics constraints.  We know the parameters
 appropriate for collinear kinematics $\sqrt{s}$, $x^c_{1,2}$.  We
 have picked values vor the momentum transfer $Q_{1,2}$ and the
 azimuthal angles $\phi_{1,2}$.  The solution consists of modified energy
 fractions $x_{1,2}$ and polar angles $\theta_{1,2}$.
 
 If the computation fails, which can happen for large momentum
 transfer, the flag [[ok]] will indicate this.
 <<Recoil kinematics: public>>=
   public :: solve_recoil
 <<Recoil kinematics: procedures>>=
   subroutine solve_recoil (sqrts, xc, xcb, phi, q2, x, xb, cos_th, sin_th, ok)
     real(default), intent(in) :: sqrts
     real(default), dimension(2), intent(in) :: xc
     real(default), dimension(2), intent(in) :: xcb
     real(default), dimension(2), intent(in) :: phi
     real(default), dimension(2), intent(in) :: q2
     real(default), dimension(2), intent(out) :: x
     real(default), dimension(2), intent(out) :: xb
     real(default), dimension(2), intent(out) :: cos_th
     real(default), dimension(2), intent(out) :: sin_th
     logical, intent(out) :: ok
 
     real(default) :: s
     real(default), dimension(2) :: ee
     real(default), dimension(2) :: th
     real(default) :: xb0, cphi
     real(default) :: che, lambda
     real(default) :: rho_new, rho, rho_old
     real(default) :: dr_old, dr_new
     real(default), parameter :: dr_limit = 100 * epsilon (1._default)
     integer, parameter :: n_it_max = 20
     integer :: i
 
     ok = .true.
 
     s = sqrts**2
     ee = sqrt ([xcb(1)/xcb(2), xcb(2)/xcb(1)])
     che = sum (ee) / 2
     xb0 = sqrt (xcb(1) * xcb(2))
     cphi = cos (phi(1) - phi(2))
 
     rho_old = 10
     rho = 1
     th = 0
     sin_th = sin (th)
     cos_th = cos (th)
     lambda = lambda_factor (sin_th, cos_th, cphi)
     call scaled_x (rho, ee, xb0, x, xb)
     
     iterate_loop: do i = 1, n_it_max
 
        call polar_angles (s, xb0, rho, ee, q2, sin_th, cos_th, ok)
        if (.not. ok)  return
        th = atan2 (sin_th, cos_th)
 
        lambda = lambda_factor (sin_th, cos_th, cphi)
        rho_new = scale_factor (che, lambda, xb0)
        call scaled_x (rho_new, ee, xb0, x, xb)
 
        dr_old = abs (rho - rho_old)
        dr_new = abs (rho_new - rho)
 
        rho_old = rho
        rho = rho_new
        
        if (dr_new < dr_limit .or. dr_new >= dr_old)  exit iterate_loop
 
     end do iterate_loop
 
   end subroutine solve_recoil
 
 @ %def solve_recoil
 @
 With all kinematics parameters known, construct actual four-vectors
 for the recoil momenta, the off-shell (spacelike) parton momenta, and
 on-shell projected parton momenta.
 <<Recoil kinematics: public>>=
   public :: recoil_momenta
 <<Recoil kinematics: procedures>>=
   subroutine recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, km, qm, qo)
     real(default), intent(in) :: sqrts
     real(default), dimension(2), intent(in) :: xc
     real(default), dimension(2), intent(in) :: xb
     real(default), dimension(2), intent(in) :: cos_th
     real(default), dimension(2), intent(in) :: sin_th
     real(default), dimension(2), intent(in) :: phi
     type(vector4_t), dimension(2), intent(out) :: km
     type(vector4_t), dimension(2), intent(out) :: qm
     type(vector4_t), dimension(2), intent(out) :: qo
 
     type(vector4_t), dimension(2) :: pm
     type(lorentz_transformation_t) :: lt
     real(default) :: sqsh
 
     pm(1) = &
          vector4_moving (sqrts/2, &
          vector3_moving ([0._default, 0._default, sqrts/2]))
     pm(2) = &
          vector4_moving (sqrts/2, &
          vector3_moving ([0._default, 0._default,-sqrts/2]))
 
     km(1) = xb(1) * (sqrts/2) * vector4_moving ( &
          1._default, &
          vector3_moving ([ &
          &     sin_th(1) * cos (phi(1)), &
          &     sin_th(1) * sin (phi(1)), &
          &     cos_th(1)]) &
          )
     km(2) = xb(2) * (sqrts/2) * vector4_moving ( &
          1._default, &
          vector3_moving ([ &
          &    -sin_th(2) * cos (phi(2)), &
          &    -sin_th(2) * sin (phi(2)), &
          &    -cos_th(2)]) &
          )
 
     qm(1) = pm(1) - km(1)
     qm(2) = pm(2) - km(2)
 
     sqsh = sqrt (xc(1)*xc(2)) * sqrts
     lt = transformation (3, qm(1), qm(2), sqsh)
 
     qo(1) = lt * vector4_moving (sqsh/2, sqsh/2, 3)
     qo(2) = lt * vector4_moving (sqsh/2,-sqsh/2, 3)
 
   end subroutine recoil_momenta
 
 @ %def recoil_momenta
 @ 
 Compute the Lorentz transformation that we can use to transform any
 outgoing momenta into the new c.m.\ system of the incoming partons.
 Not relying on the previous calculations, we determine the
 transformation that transforms the original collinear partons into
 their c.m.\ system, and then transform this to the new c.m.\ system.
 <<Recoil kinematics: public>>=
   public :: recoil_transformation
 <<Recoil kinematics: procedures>>=
   subroutine recoil_transformation (sqrts, xc, qo, lt)
     real(default), intent(in) :: sqrts
     real(default), dimension(2), intent(in) :: xc
     type(vector4_t), dimension(2), intent(in) :: qo
     type(lorentz_transformation_t), intent(out) :: lt
 
     real(default) :: sqsh
     type(vector4_t), dimension(2) :: qc
     type(lorentz_transformation_t) :: ltc, lto
     
     qc(1) = xc(1) * vector4_moving (sqrts/2, sqrts/2, 3)
     qc(2) = xc(2) * vector4_moving (sqrts/2,-sqrts/2, 3)
     
     sqsh = sqrt (xc(1) * xc(2)) * sqrts
     ltc = transformation (3, qc(1), qc(2), sqsh)
     lto = transformation (3, qo(1), qo(2), sqsh)
     lt = lto * inverse (ltc)
 
   end subroutine recoil_transformation
   
 @ %def recoil_transformation
 @
 Compute the Lorentz boost that transforms the c.m.\ frame of the
 momenta into the lab frame where they are given.  Also return their
 common invariant mass, $\sqrt{s}$.
 
 If the initial momenta are not collinear, [[ok]] is set false.
 <<Recoil kinematics: public>>=
   public :: initial_transformation
 <<Recoil kinematics: procedures>>=
   subroutine initial_transformation (p, sqrts, lt, ok)
     type(vector4_t), dimension(2), intent(in) :: p
     real(default), intent(out) :: sqrts
     type(lorentz_transformation_t), intent(out) :: lt
     logical, intent(out) :: ok
     
     ok = all (transverse_part (p) == 0)
 
     sqrts = (p(1) + p(2)) ** 1
     lt = boost (p(1) + p(2), sqrts)
 
   end subroutine initial_transformation
   
 @ %def initial_transformation
 @
 \subsection{Generate recoil event}
 Combine the above kinematics calculations.  First generate azimuthal
 angles and momentum transfer, solve kinematics and compute momenta for
 the radiated photons and the on-shell projected, recoiling partons.
 
 If [[ok]] is false, the data point has failed and we should repeat the
 procedure for a new set of RNG parameters [[r]].
 <<Recoil kinematics: public>>=
   public :: generate_recoil
 <<Recoil kinematics: procedures>>=
   subroutine generate_recoil (sqrts, q_max, m, xc, xcb, r, km, qm, qo, ok)
     real(default), intent(in) :: sqrts
     real(default), intent(in), dimension(2) :: q_max
     real(default), intent(in), dimension(2) :: m
     real(default), intent(in), dimension(2) :: xc
     real(default), intent(in), dimension(2) :: xcb
     real(default), intent(in), dimension(4) :: r
     type(vector4_t), dimension(2), intent(out) :: km
     type(vector4_t), dimension(2), intent(out) :: qm
     type(vector4_t), dimension(2), intent(out) :: qo
     logical, intent(out) :: ok
 
     real(default), dimension(2) :: q2
     real(default), dimension(2) :: phi
     real(default), dimension(2) :: x
     real(default), dimension(2) :: xb
     real(default), dimension(2) :: cos_th
     real(default), dimension(2) :: sin_th
 
     call generate_q2_recoil (sqrts**2, xcb, q_max**2, m**2, r(1:2), q2)
     call generate_phi_recoil (r(3:4), phi)
     
     call solve_recoil (sqrts, xc, xcb, phi, q2, x, xb, cos_th, sin_th, ok)
     if (ok) then
        call recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, km, qm, qo)
     end if
 
   end subroutine generate_recoil
   
 @ %def generate_recoil
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[recoil_kinematics_ut.f90]]>>=
 <<File header>>
 
 module recoil_kinematics_ut
   use unit_tests
   use recoil_kinematics_uti
 
 <<Standard module head>>
 
 <<Recoil kinematics: public test>>
 
 contains
 
 <<Recoil kinematics: test driver>>
 
 end module recoil_kinematics_ut
 @ %def recoil_kinematics_ut
 @
 <<[[recoil_kinematics_uti.f90]]>>=
 <<File header>>
 
 module recoil_kinematics_uti
 
 <<Use kinds>>
   use constants, only: twopi
   use constants, only: degree
   use lorentz, only: vector4_t
   use lorentz, only: vector4_moving
   use lorentz, only: lorentz_transformation_t
   use lorentz, only: inverse
   use lorentz, only: operator(+)
   use lorentz, only: operator(*)
   use lorentz, only: operator(**)
   use lorentz, only: pacify
 
   use recoil_kinematics, only: solve_recoil
   use recoil_kinematics, only: recoil_momenta
   use recoil_kinematics, only: recoil_transformation
   use recoil_kinematics, only: initial_transformation
   use recoil_kinematics, only: generate_q2_recoil
   use recoil_kinematics, only: generate_recoil
 
 <<Standard module head>>
 
 <<Recoil kinematics: test declarations>>
 
 contains
 
 <<Recoil kinematics: tests>>
 
 end module recoil_kinematics_uti
 
 @ %def recoil_kinematics_uti
 @ API: driver for the unit tests below.
 <<Recoil kinematics: public test>>=
   public :: recoil_kinematics_test
 <<Recoil kinematics: test driver>>=
   subroutine recoil_kinematics_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Recoil kinematics: execute tests>>
   end subroutine recoil_kinematics_test
 
 @ %def recoil_kinematics_test
 @
 \subsubsection{Recoil kinematics}
 For a set of input data, solve the kinematics constraints and generate
 momenta accordingly.
 <<Recoil kinematics: execute tests>>=
   call test (recoil_kinematics_1, "recoil_kinematics_1", &
        "iterative solution of non-collinear kinematics", &
        u, results)
 <<Recoil kinematics: test declarations>>=
   public :: recoil_kinematics_1
 <<Recoil kinematics: tests>>=
   subroutine recoil_kinematics_1 (u)
     integer, intent(in) :: u
 
     real(default) :: sqrts
     real(default), dimension(2) :: xc, xcb
     real(default), dimension(2) :: q
     real(default), dimension(2) :: phi
     real(default), dimension(2) :: cos_th, sin_th
     real(default), dimension(2) :: x
     real(default), dimension(2) :: xb
     type(vector4_t), dimension(2) :: km
     type(vector4_t), dimension(2) :: qm
     type(vector4_t), dimension(2) :: qo
     integer :: i
     logical :: ok
     
     character(*), parameter :: FMT1 = "(1x,A,9(1x,F15.10))"
     character(*), parameter :: FMT2 = "(1x,A,9(1x,F10.5))"
     character(*), parameter :: FMT4 = "(3x,ES8.1,9(1x,ES19.12))"
 
     write (u, "(A)")  "* Test output: recoil_kinematics_1"
     write (u, "(A)")  "*   Purpose: compute kinematics for various input data"
     write (u, "(A)")
 
     sqrts = 100
     write (u, FMT1)  "sqrts =", sqrts
     
     write (u, "(A)")
     write (u, "(A)") "*** collinear data set"
     write (u, "(A)")
 
     xc = [0.6_default, 0.9_default]
     xcb = 1 - xc
     phi = [0.1_default, 0.2_default] * twopi
     q = 0
 
     call show_data
     call solve_recoil (sqrts, xc, xcb, phi, q**2, x, xb, cos_th, sin_th, ok)
     call show_results
 
     call recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, km, qm, qo)
     call show_momenta
 
     write (u, "(A)")
     write (u, "(A)") "*** moderate data set"
     write (u, "(A)")
 
     xc = [0.6_default, 0.9_default]
     xcb = 1 - xc
     phi = [0.1_default, 0.2_default] * twopi
     q = [0.2_default, 0.05_default] * sqrts
 
     call show_data
     call solve_recoil (sqrts, xc, xcb, phi, q**2, x, xb, cos_th, sin_th, ok)
     call show_results
     
     call recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, km, qm, qo)
     call show_momenta
 
     write (u, "(A)")
     write (u, "(A)") "*** semi-soft data set"
     write (u, "(A)")
 
     xcb= [0.1_default, 0.0001_default]
     xc = 1 - xcb
     phi = [0.1_default, 0.2_default] * twopi
     q = [0.2_default, 0.00001_default] * sqrts
 
     call show_data
     call solve_recoil (sqrts, xc, xcb, phi, q**2, x, xb, cos_th, sin_th, ok)
     call show_results
 
     call recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, km, qm, qo)
     call show_momenta
 
     write (u, "(A)")
     write (u, "(A)") "*** hard-soft data set"
     write (u, "(A)")
 
     xcb= [0.1_default, 1.e-30_default]
     xc = 1 - xcb
     phi = [0.1_default, 0.2_default] * twopi
     q = [0.2_default, 1.e-35_default] * sqrts
 
     call show_data
     call solve_recoil (sqrts, xc, xcb, phi, q**2, x, xb, cos_th, sin_th, ok)
     call show_results
 
     call recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, km, qm, qo)
     call show_momenta
 
     write (u, "(A)")
     write (u, "(A)") "*** hard data set"
     write (u, "(A)")
 
     xc = [0.2_default, 0.4_default]
     xcb = 1 - xc
     phi = [0.1_default, 0.8_default] * twopi
     q = [0.74_default, 0.3_default] * sqrts
 
     call show_data
     call solve_recoil (sqrts, xc, xcb, phi, q**2, x, xb, cos_th, sin_th, ok)
     call show_results
 
     call recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, km, qm, qo)
     call show_momenta
 
     write (u, "(A)")
     write (u, "(A)") "*** failing data set"
     write (u, "(A)")
 
     xc = [0.2_default, 0.4_default]
     xcb = 1 - xc
     phi = [0.1_default, 0.8_default] * twopi
     q = [0.9_default, 0.3_default] * sqrts
     
     call show_data
     call solve_recoil (sqrts, xc, xcb, phi, q**2, x, xb, cos_th, sin_th, ok)
     if (.not. ok) then
        write (u, "(A)")
        write (u, "(A)") "Failed as expected."
     end if
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: recoil_kinematics_1"
 
   contains
 
     subroutine show_data
       write (u, FMT1) "sqs_h =", sqrt (xc(1) * xc(2)) * sqrts
       write (u, FMT1) "xc    =", xc
       write (u, FMT1) "xcb   =", xcb
       write (u, FMT1) "Q     =", Q
       write (u, FMT1) "phi/D =", phi / degree
     end subroutine show_data
 
     subroutine show_results
       write (u, "(A)")
       write (u, "(A)") "Result:"
       write (u, FMT1) "th/D  =", atan2 (sin_th, cos_th) / degree
       write (u, FMT1) "x     =", x
       write (u, "(A)")
     end subroutine show_results
     
     subroutine show_momenta
       type(vector4_t) :: qm0, qo0
       real(default), parameter :: tol = 1.e-7_default
       call pacify (km, tol)
       call pacify (qm, tol)
       call pacify (qo, tol)
       write (u, "(A)") "Momenta: k"
       call km(1)%write (u, testflag=.true.)
       call km(2)%write (u, testflag=.true.)
       write (u, FMT1) "k^2 =", abs (km(1)**2), abs (km(2)**2)
       write (u, "(A)")
       write (u, "(A)") "Momenta: q"
       call qm(1)%write (u, testflag=.true.)
       call qm(2)%write (u, testflag=.true.)
       write (u, "(A)")
       write (u, "(A)") "Momenta: q(os)"
       call qo(1)%write (u, testflag=.true.)
       call qo(2)%write (u, testflag=.true.)
       write (u, "(A)")
       write (u, "(A)") "Check: parton momentum sum: q vs q(os)"
       qm0 = qm(1) + qm(2)
       call qm0%write (u, testflag=.true.)
       qo0 = qo(1) + qo(2)
       call qo0%write (u, testflag=.true.)
       write (u, "(A)")
       write (u, "(A)") "* Check: momentum transfer (off-shell/on-shell)"
       write (u, FMT2) "|q| =", abs (qm(1)**1), abs (qm(2)**1)
       write (u, FMT2) "Q   =", q
       write (u, FMT2) "|qo|=", abs (qo(1)**1), abs (qo(2)**1)
       write (u, "(A)")
       write (u, "(A)") "* Check: sqrts, sqrts_hat"
       write (u, FMT1) "|p| =", (km(1)+km(2)+qm(1)+qm(2))**1, (qm(1)+qm(2))**1
       write (u, FMT1) "sqs =", sqrts, sqrt (product (xc)) * sqrts
       write (u, FMT1) "|po|=", abs ((km(1)+km(2)+qo(1)+qo(2))**1), abs ((qo(1)+qo(2))**1)
     end subroutine show_momenta
 
   end subroutine recoil_kinematics_1
 
 @ %def recoil_kinematics_1
 @
 \subsubsection{Recoil $Q$ distribution}
 Sample the $Q$ distribution for equidistant bins in the input variable.
 <<Recoil kinematics: execute tests>>=
   call test (recoil_kinematics_2, "recoil_kinematics_2", &
        "Q distribution", &
        u, results)
 <<Recoil kinematics: test declarations>>=
   public :: recoil_kinematics_2
 <<Recoil kinematics: tests>>=
   subroutine recoil_kinematics_2 (u)
     integer, intent(in) :: u
 
     real(default) :: sqrts
     real(default) :: q_max
     real(default) :: m
     real(default) :: x_bar
     real(default) :: r
     real(default) :: q2, q2_old
     integer :: i
     integer :: n_bin
     
     character(*), parameter :: FMT1 = "(1x,A,9(1x,F15.10))"
     character(*), parameter :: FMT3 = "(2x,9(1x,F10.5))"
 
     write (u, "(A)")  "* Test output: recoil_kinematics_2"
     write (u, "(A)")  "*   Purpose: compute Q distribution"
     write (u, "(A)")
 
     n_bin = 20
 
     write (u, "(A)") "* No Q cutoff, xbar = 1"
     write (u, "(A)")
 
     sqrts = 100
     q_max = sqrts
     m = 0.511e-3_default
     x_bar = 1._default
     call show_table
 
     write (u, "(A)")
     write (u, "(A)") "* With Q cutoff, xbar = 1"
     write (u, "(A)")
 
     q_max = 10
     call show_table
 
     write (u, "(A)")
     write (u, "(A)") "* No Q cutoff, xbar = 0.01"
     write (u, "(A)")
 
     q_max = sqrts
     x_bar = 0.01_default
     call show_table
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: recoil_kinematics_2"
 
   contains
     
     subroutine show_table
       write (u, FMT1)  "sqrts =", sqrts
       write (u, FMT1)  "q_max =", q_max
       write (u, FMT1)  "m     =", m
       write (u, FMT1)  "x_bar =", x_bar
       write (u, "(A)")
       write (u, "(1x,A)")  "Table:  r         |Q|    |Q_i/Q_(i-1)|"
       q2_old = 0
       do i = 0, n_bin
          r = real (i, default) / n_bin
          call generate_q2_recoil (sqrts**2, x_bar, q_max**2, m**2, r, q2)
          if (q2_old > 0) then
             write (u, FMT3)  r, sqrt (q2), sqrt (q2 / q2_old)
          else
             write (u, FMT3)  r, sqrt (q2)
          end if
          q2_old = q2
       end do
     end subroutine show_table
     
   end subroutine recoil_kinematics_2
 
 @ %def recoil_kinematics_2
 @
 \subsubsection{Generate recoil event}
 Combine $Q^2$ sampling with momentum generation.
 <<Recoil kinematics: execute tests>>=
   call test (recoil_kinematics_3, "recoil_kinematics_3", &
        "generate recoil event", &
        u, results)
 <<Recoil kinematics: test declarations>>=
   public :: recoil_kinematics_3
 <<Recoil kinematics: tests>>=
   subroutine recoil_kinematics_3 (u)
     integer, intent(in) :: u
 
     real(default) :: sqrts
     real(default), dimension(2) :: q_max
     real(default), dimension(2) :: m
     real(default), dimension(2) :: xc, xcb
     real(default), dimension(4) :: r
     type(vector4_t), dimension(2) :: km
     type(vector4_t), dimension(2) :: qm
     type(vector4_t), dimension(2) :: qo
     logical :: ok
     
     character(*), parameter :: FMT1 = "(1x,A,9(1x,F15.10))"
     character(*), parameter :: FMT2 = "(1x,A,9(1x,F10.5))"
 
     write (u, "(A)")  "* Test output: recoil_kinematics_3"
     write (u, "(A)")  "*   Purpose: generate momenta from RNG parameters"
     write (u, "(A)")
 
     write (u, "(A)") "*** collinear data set"
     write (u, "(A)")
 
     sqrts = 100
     q_max = sqrts
     m     = 0.511e-3_default
 
     xc = [0.6_default, 0.9_default]
     xcb = 1 - xc
 
     r = [0._default, 0._default, 0._default, 0._default]
 
     call show_data
     call generate_recoil (sqrts, q_max, m, xc, xcb, r, km, qm, qo, ok)
     call show_momenta
 
     write (u, "(A)")
     write (u, "(A)") "*** moderate data set"
     write (u, "(A)")
 
     xc = [0.6_default, 0.9_default]
     xcb = 1 - xc
 
     r = [0.8_default, 0.2_default, 0.1_default, 0.2_default]
 
     call show_data
     call generate_recoil (sqrts, q_max, m, xc, xcb, r, km, qm, qo, ok)
     call show_momenta
 
     write (u, "(A)")
     write (u, "(A)") "*** failing data set"
     write (u, "(A)")
 
     xc = [0.2_default, 0.4_default]
     xcb = 1 - xc
     
     r = [0.9999_default, 0.3_default, 0.1_default, 0.8_default]
 
     call show_data
     call generate_recoil (sqrts, q_max, m, xc, xcb, r, km, qm, qo, ok)
     if (.not. ok) then
        write (u, "(A)")
        write (u, "(A)") "Failed as expected."
     else
        call show_momenta
     end if
     
   contains
     
     subroutine show_data
       write (u, FMT1)  "sqrts =", sqrts
       write (u, FMT1)  "q_max =", q_max
       write (u, FMT1)  "m     =", m
       write (u, FMT1)  "xc    =", xc
       write (u, FMT1)  "xcb   =", xcb
       write (u, FMT1)  "r     =", r
     end subroutine show_data
     
     subroutine show_momenta
       real(default), parameter :: tol = 1.e-7_default
       call pacify (km, tol)
       call pacify (qo, tol)
       write (u, "(A)")
       write (u, "(A)") "* Momenta: k"
       call km(1)%write (u, testflag=.true.)
       call km(2)%write (u, testflag=.true.)
       write (u, FMT1) "k^2 =", abs (km(1)**2), abs (km(2)**2)
       write (u, "(A)")
       write (u, "(A)") "* Momenta: q(os)"
       call qo(1)%write (u, testflag=.true.)
       call qo(2)%write (u, testflag=.true.)
       write (u, FMT1) "q^2 =", abs (qo(1)**2), abs (qo(2)**2)
       write (u, "(A)")
       write (u, "(A)") "* Check: momentum transfer (off-shell/on-shell)"
       write (u, FMT2) "Q   =", q_check (1), q_check (2)
       write (u, FMT2) "|q| =", abs (qm(1)**1), abs (qm(2)**1)
       write (u, "(A)")
       write (u, "(A)") "* Check: sqrts, sqrts_hat"
       write (u, FMT1) "sqs =", sqrts, sqrt (product (xc)) * sqrts
       write (u, FMT1) "|po|=", abs ((km(1)+km(2)+qo(1)+qo(2))**1), abs ((qo(1)+qo(2))**1)
     end subroutine show_momenta
     
     function q_check (i) result (q)
       integer, intent(in) :: i
       real(default) :: q
       real(default) :: q2
       call generate_q2_recoil (sqrts**2, xcb(i), q_max(i)**2, m(i)**2, r(i), q2)
       q = sqrt (q2)
     end function q_check
 
   end subroutine recoil_kinematics_3
 
 @ %def recoil_kinematics_3
 @
 \subsubsection{Transformation after recoil}
 Given a solution to recoil kinematics, compute the Lorentz
 transformation that transforms the old collinear parton momenta into
 the new parton momenta.
 <<Recoil kinematics: execute tests>>=
   call test (recoil_kinematics_4, "recoil_kinematics_4", &
        "reference frame", &
        u, results)
 <<Recoil kinematics: test declarations>>=
   public :: recoil_kinematics_4
 <<Recoil kinematics: tests>>=
   subroutine recoil_kinematics_4 (u)
     integer, intent(in) :: u
 
     real(default) :: sqrts
     real(default), dimension(2) :: xc, xcb
     real(default), dimension(2) :: q
     real(default), dimension(2) :: phi
     real(default), dimension(2) :: cos_th, sin_th
     real(default), dimension(2) :: x
     real(default), dimension(2) :: xb
     type(vector4_t), dimension(2) :: km
     type(vector4_t), dimension(2) :: qm
     type(vector4_t), dimension(2) :: qo
     type(lorentz_transformation_t) :: lt
     logical :: ok
     
     character(*), parameter :: FMT1 = "(1x,A,9(1x,F15.10))"
     character(*), parameter :: FMT2 = "(1x,A,9(1x,F10.5))"
 
     write (u, "(A)")  "* Test output: recoil_kinematics_4"
     write (u, "(A)")  "*   Purpose: check Lorentz transformation for recoil"
     write (u, "(A)")
 
     sqrts = 100
     write (u, FMT1)  "sqrts =", sqrts
     
 
     write (u, "(A)")
     write (u, "(A)") "*** collinear data set"
     write (u, "(A)")
 
     xc = [0.6_default, 0.9_default]
     xcb = 1 - xc
     phi = [0.1_default, 0.2_default] * twopi
     q = 0
 
     call show_data
     call solve_recoil (sqrts, xc, xcb, phi, q**2, x, xb, cos_th, sin_th, ok)
     call recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, km, qm, qo)
     call recoil_transformation (sqrts, xc, qo, lt)
     call show_transformation
 
     write (u, "(A)")
     write (u, "(A)") "*** moderate data set"
     write (u, "(A)")
 
     xc = [0.6_default, 0.9_default]
     xcb = 1 - xc
     phi = [0.1_default, 0.2_default] * twopi
     q = [0.2_default, 0.05_default] * sqrts
 
     call show_data
     call solve_recoil (sqrts, xc, xcb, phi, q**2, x, xb, cos_th, sin_th, ok)
     call recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, km, qm, qo)
     call recoil_transformation (sqrts, xc, qo, lt)
     call show_transformation
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: recoil_kinematics_4"
 
   contains
 
     subroutine show_data
       write (u, FMT1) "sqs_h =", sqrt (xc(1) * xc(2)) * sqrts
       write (u, FMT1) "xc    =", xc
       write (u, FMT1) "xcb   =", xcb
       write (u, FMT1) "Q     =", Q
       write (u, FMT1) "phi/D =", phi / degree
     end subroutine show_data
 
     subroutine show_transformation
       type(vector4_t), dimension(2) :: qc
       type(vector4_t), dimension(2) :: qct
       real(default), parameter :: tol = 1.e-7_default
       qc(1) = xc(1) * vector4_moving (sqrts/2, sqrts/2, 3)
       qc(2) = xc(2) * vector4_moving (sqrts/2,-sqrts/2, 3)
       qct = lt * qc
       call pacify (qct, tol)
       write (u, "(A)")
       write (u, "(A)") "Momenta: q(os)"
       call qo(1)%write (u, testflag=.true.)
       call qo(2)%write (u, testflag=.true.)
       write (u, "(A)")
       write (u, "(A)") "Momenta: LT * qc"
       call qct(1)%write (u, testflag=.true.)
       call qct(2)%write (u, testflag=.true.)
     end subroutine show_transformation
 
   end subroutine recoil_kinematics_4
 
 @ %def recoil_kinematics_4
 @
 \subsubsection{Transformation before recoil}
 Given a pair of incoming `beam' partons (i.e., before ISR splitting),
 compute the transformation that transforms their common c.m.\ frame
 into the lab frame.
 <<Recoil kinematics: execute tests>>=
   call test (recoil_kinematics_5, "recoil_kinematics_5", &
        "initial reference frame", &
        u, results)
 <<Recoil kinematics: test declarations>>=
   public :: recoil_kinematics_5
 <<Recoil kinematics: tests>>=
   subroutine recoil_kinematics_5 (u)
     integer, intent(in) :: u
 
     real(default) :: sqrts
     real(default) :: sqrtsi
     real(default), dimension(2) :: x
     type(vector4_t), dimension(2) :: p
     type(vector4_t), dimension(2) :: pi
     type(vector4_t), dimension(2) :: p0
     type(lorentz_transformation_t) :: lt
     logical :: ok
     
     character(*), parameter :: FMT1 = "(1x,A,9(1x,F15.10))"
     character(*), parameter :: FMT2 = "(1x,A,9(1x,F10.5))"
 
     write (u, "(A)")  "* Test output: recoil_kinematics_5"
     write (u, "(A)")  "*   Purpose: determine initial Lorentz transformation"
     write (u, "(A)")
 
     sqrts = 100
     write (u, FMT1)  "sqrts =", sqrts
     
     x = [0.6_default, 0.9_default]
 
     p(1) = x(1) * vector4_moving (sqrts/2, sqrts/2, 3)
     p(2) = x(2) * vector4_moving (sqrts/2,-sqrts/2, 3)
 
     call show_data
     call initial_transformation (p, sqrtsi, lt, ok)
     
     pi(1) = vector4_moving (sqrtsi/2, sqrtsi/2, 3)
     pi(2) = vector4_moving (sqrtsi/2,-sqrtsi/2, 3)
 
     p0 = inverse (lt) * p
     
     call show_momenta
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: recoil_kinematics_5"
 
   contains
 
     subroutine show_data
       write (u, FMT1) "sqrts =", sqrts
       write (u, FMT1) "x     =", x
     end subroutine show_data
 
     
     subroutine show_momenta
       real(default), parameter :: tol = 1.e-7_default
       write (u, "(A)")
       write (u, "(A)") "* Momenta: p_in(c.m.)"
       call pi(1)%write (u, testflag=.true.)
       call pi(2)%write (u, testflag=.true.)
       write (u, "(A)")
       write (u, "(A)") "* Momenta: inv(LT) * p_in(lab)"
       call p0(1)%write (u, testflag=.true.)
       call p0(2)%write (u, testflag=.true.)
     end subroutine show_momenta
 
   end subroutine recoil_kinematics_5
 
 @ %def recoil_kinematics_5
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Transverse momentum for the ISR and EPA approximations}
 
 The ISR and EPA handler takes an event with a single radiated collinear
 particle (photon for ISR, beam particle for EPA) for each beam, respectively,
 and inserts transverse momentum for both.  The four-particle kinematics allows
 us to generate $Q^2$ and azimuthal angles independently, without violating
 energy-momentum conservation.  The $Q^2$ distribution is logarithmic, as
 required by the effective particle approximation, and reflected in the
 inclusive ISR/EPA structure functions.  We also conserve the invariant mass of
 the partonic systm after radiation.  The total transverse-momentum kick is
 applied in form of a Lorentz transformation to the elementary process, both
 in- and out-particles.  In fact, the incoming partons (beam particle for ISR,
 photon for EPA) which would be virtual space-like in the exact kinematics
 configuration, are replaced by on-shell incoming partons, such that energy,
 momentum, and invariant mass $\sqrt{\hat s}$ are conserved.
 
 Regarding kinematics, we treat all particles as massless.  The beam-particle
 mass only appears as the parameter [[isr_mass]] or [[epa_mass]], respectively,
 and cuts off the logarithmic distribution.  The upper cutoff is [[isr_q_max]]
 ([[epa_q_max]]), which defaults to the available energy $\sqrt{s}$.
 
 The only differences between ISR and EPA, in this context, are the particle
 types, and an extra $\bar x$ factor in the lower cutoff for EPA, see below.
 <<[[isr_epa_handler.f90]]>>=
 <<File header>>
 
 module isr_epa_handler
 
 <<Use kinds>>
 <<Use strings>>
   use diagnostics, only: msg_fatal
   use diagnostics, only: msg_bug
   use io_units
   use format_defs, only: FMT_12, FMT_19
   use format_utils, only: write_separator
   use format_utils, only: pac_fmt
   use physics_defs, only: PHOTON
   use lorentz, only: vector4_t
   use lorentz, only: energy
   use lorentz, only: lorentz_transformation_t
   use lorentz, only: identity
   use lorentz, only: inverse
   use lorentz, only: operator(*)
   use sm_qcd
   use flavors, only: flavor_t
   use particles, only: particle_t
   use model_data
   use models
   use rng_base, only: rng_t
   use event_transforms
   use recoil_kinematics, only: initial_transformation
   use recoil_kinematics, only: generate_recoil
   use recoil_kinematics, only: recoil_transformation
 
 <<Standard module head>>
 
 <<ISR/EPA handler: public>>
 
 <<ISR/EPA handler: parameters>>
 
 <<ISR/EPA handler: types>>
 
 contains
 
 <<ISR/EPA handler: procedures>>
 
 end module isr_epa_handler
 @ %def isr_epa_handler
 @
 \subsection{Event transform type}
 Convention: [[beam]] are the incoming partons before ISR -- not
 necessarily the actual beams, need not be in c.m.\ frame.  [[radiated]]
 are the radiated particles (photon for ISR), and [[parton]] are the
 remainders which 
 initiate the elementary process.  These particles are copied verbatim
 from the event record, and must be collinear.
 
 The kinematical parameters are [[sqrts]] = invariant mass of the
 [[beam]] particles, [[q_max]] and [[m]] determining the $Q^2$
 distribution, and [[xc]]/[[xcb]] as the energy fraction (complement)
 of the partons, relative to the beams.
 
 Transformations: [[lti]] is the Lorentz transformation that would
 boosts [[pi]] (c.m. frame) back to the original [[beam]] momenta (lab
 frame).  [[lto]] is the recoil transformation, transforming the partons
 after ISR from the collinear frame to the recoiling frame.  [[lt]] is
 the combination of both, which is to be applied to all particles after
 the hard interaction.
 
 Momenta: [[pi]] are the beams transformed to their common c.m.\ frame.
 [[ki]] and [[qi]] are the photon/parton
 momenta in the [[pi]] c.m.\ frame.  [[km]] and [[qm]] are the
 photon/parton momenta with the $Q$ distribution applied, and finally
 [[qo]] are the partons [[qm]] projected on-shell.
 <<ISR/EPA handler: public>>=
   public :: evt_isr_epa_t
 <<ISR/EPA handler: types>>=
   type, extends (evt_t) :: evt_isr_epa_t
      private
      integer :: mode = ISR_TRIVIAL_COLLINEAR
      logical :: isr_active = .false.
      logical :: epa_active = .false.
      real(default) :: isr_q_max = 0
      real(default) :: epa_q_max = 0
      real(default) :: isr_mass = 0
      real(default) :: epa_mass = 0
      real(default) :: sqrts = 0
      integer, dimension(2) :: rad_mode = BEAM_RAD_NONE
      real(default), dimension(2) :: q_max = 0
      real(default), dimension(2) :: m = 0
      real(default), dimension(2) :: xc = 0
      real(default), dimension(2) :: xcb = 0
      type(lorentz_transformation_t) :: lti = identity
      type(lorentz_transformation_t) :: lto = identity
      type(lorentz_transformation_t) :: lt  = identity
      integer, dimension(2) :: i_beam = 0
      type(particle_t), dimension(2) :: beam
      type(vector4_t), dimension(2) :: pi
      integer, dimension(2) :: i_radiated = 0
      type(particle_t), dimension(2) :: radiated
      type(vector4_t), dimension(2) :: ki
      type(vector4_t), dimension(2) :: km
      integer, dimension(2) :: i_parton = 0
      type(particle_t), dimension(2) :: parton
      type(vector4_t), dimension(2) :: qi
      type(vector4_t), dimension(2) :: qm
      type(vector4_t), dimension(2) :: qo
    contains
    <<ISR/EPA handler: evt isr: TBP>>
   end type evt_isr_epa_t
 
 @ %def evt_isr_epa_t
 @
 \subsection{ISR/EPA distinction}
 <<ISR/EPA handler: parameters>>=
   integer, parameter, public :: BEAM_RAD_NONE = 0
   integer, parameter, public :: BEAM_RAD_ISR = 1
   integer, parameter, public :: BEAM_RAD_EPA = 2
   
 @ %def BEAM_RAD_NONE
 @ %def BEAM_RAD_ISR
 @ %def BEAM_RAD_EPA
 <<ISR/EPA handler: procedures>>=
   function rad_mode_string (mode) result (string)
     type(string_t) :: string
     integer, intent(in) :: mode
     select case (mode)
     case (BEAM_RAD_NONE);  string = "---"
     case (BEAM_RAD_ISR);   string = "ISR"
     case (BEAM_RAD_EPA);   string = "EPA"
     case default;  string = "???"
     end select
   end function rad_mode_string
   
 @ %def rad_mode_string
 @
 \subsection{Photon insertion modes}
 <<ISR/EPA handler: parameters>>=
   integer, parameter, public :: ISR_TRIVIAL_COLLINEAR = 0
   integer, parameter, public :: ISR_PAIR_RECOIL = 1
   
 @ %def ISR_TRIVIAL_COLLINEAR ISR_PAIR_RECOIL
 @
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: get_mode_string => evt_isr_epa_get_mode_string
 <<ISR/EPA handler: procedures>>=
   function evt_isr_epa_get_mode_string (evt) result (string)
     type(string_t) :: string
     class(evt_isr_epa_t), intent(in) :: evt
     select case (evt%mode)
     case (ISR_TRIVIAL_COLLINEAR)
        string = "trivial, collinear"
     case (ISR_PAIR_RECOIL)
        string = "pair recoil"
     case default
        string = "[undefined]"
     end select
   end function evt_isr_epa_get_mode_string
 
 @ %def evt_isr_epa_get_mode_string
 @ Set the numerical mode ID from a user-level string representation.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: set_mode_string => evt_isr_epa_set_mode_string
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_set_mode_string (evt, string)
     class(evt_isr_epa_t), intent(inout) :: evt
     type(string_t), intent(in) :: string
     select case (char (string))
     case ("trivial")
        evt%mode = ISR_TRIVIAL_COLLINEAR
     case ("recoil")
        evt%mode = ISR_PAIR_RECOIL
     case default
        call msg_fatal ("ISR handler: mode '" // char (string) &
             // "' is undefined")
     end select
   end subroutine evt_isr_epa_set_mode_string
 
 @ %def evt_isr_epa_set_mode_string
 @ 
 \subsection{Output}
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: write_name => evt_isr_epa_write_name
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_write_name (evt, unit)
     class(evt_isr_epa_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A)")  "Event transform: ISR/EPA handler"
   end subroutine evt_isr_epa_write_name
 
 @ %def evt_isr_epa_write_name
 @ The overall recoil-handling mode.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: write_mode => evt_isr_epa_write_mode
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_write_mode (evt, unit)
     class(evt_isr_epa_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A,1x,I0,':',1x,A)")  "Insertion mode =", evt%mode, &
          char (evt%get_mode_string ())
   end subroutine evt_isr_epa_write_mode
   
 @ %def evt_isr_epa_write_mode
 @ The input data for ISR and EPA, respectively.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: write_input => evt_isr_epa_write_input
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_write_input (evt, unit, testflag)
     class(evt_isr_epa_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: testflag
     character(len=7) :: fmt
     integer :: u
     u = given_output_unit (unit)
     call pac_fmt (fmt, FMT_19, FMT_12, testflag)
     if (evt%isr_active) then
        write (u, "(3x,A,1x," // fmt // ")") "ISR: Q_max =", evt%isr_q_max
        write (u, "(3x,A,1x," // fmt // ")") "     m     =", evt%isr_mass
     else
        write (u, "(3x,A)") "ISR: [inactive]"
     end if
     if (evt%epa_active) then
        write (u, "(3x,A,1x," // fmt // ")") "EPA: Q_max =", evt%epa_q_max
        write (u, "(3x,A,1x," // fmt // ")") "     m     =", evt%epa_mass
     else
        write (u, "(3x,A)") "EPA: [inactive]"
     end if
   end subroutine evt_isr_epa_write_input
 
 @ %def evt_isr_epa_write_input
 @ The trivial mode does not depend on any data, since it does nothing
 to the event.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: write_data => evt_isr_epa_write_data
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_write_data (evt, unit, testflag)
     class(evt_isr_epa_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: testflag
     character(len=7), parameter :: FMTL_19 = "A3,16x"
     character(len=7), parameter :: FMTL_12 = "A3,9x"
     character(len=7) :: fmt, fmtl
     integer :: u
     u = given_output_unit (unit)
     call pac_fmt (fmt, FMT_19, FMT_12, testflag)
     call pac_fmt (fmtl, FMTL_19, FMTL_12, testflag)
     select case (evt%mode)
     case (ISR_PAIR_RECOIL)
        write (u, "(1x,A)")  "Event:"
        write (u, "(3x,A,2(1x," // fmtl // "))") &
             "mode  = ", &
             char (rad_mode_string (evt%rad_mode(1))), &
             char (rad_mode_string (evt%rad_mode(2)))
        write (u, "(3x,A,2(1x," // fmt // "))") "Q_max =", evt%q_max
        write (u, "(3x,A,2(1x," // fmt // "))") "m     =", evt%m
        write (u, "(3x,A,2(1x," // fmt // "))") "x     =", evt%xc
        write (u, "(3x,A,2(1x," // fmt // "))") "xb    =", evt%xcb
        write (u, "(3x,A,1x," // fmt // ")")    "sqrts =", evt%sqrts
        call write_separator (u)
        write (u, "(A)")  "Lorentz boost (partons before radiation &
             &c.m. -> lab) ="
        call evt%lti%write (u, testflag)
        write (u, "(A)")  "Lorentz transformation (collinear partons &
             &-> partons with recoil in c.m.) ="
        call evt%lto%write (u, testflag)
        write (u, "(A)")  "Combined transformation (partons &
             &-> partons with recoil in lab frame) ="
        call evt%lt%write (u, testflag)
     end select
   end subroutine evt_isr_epa_write_data
 
 @ %def evt_isr_epa_write_data
 @ Output method.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: write => evt_isr_epa_write
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_write (evt, unit, verbose, more_verbose, testflag)
     class(evt_isr_epa_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose, more_verbose, testflag
     logical :: show_mass
     integer :: u, i
     u = given_output_unit (unit)
     if (present (testflag)) then
        show_mass = .not. testflag
     else
        show_mass = .true.
     end if
     call write_separator (u, 2)
     call evt%write_name (u)
     call write_separator (u, 2)
     call evt%write_mode (u)
     call evt%write_input (u, testflag=testflag)
     call evt%write_data (u, testflag=testflag)
     call write_separator (u)
     call evt%base_write (u, testflag = testflag, show_set = .false.)
     if (all (evt%i_beam > 0)) then
        call write_separator (u)
        write (u, "(A,2(1x,I0))")  "Partons before radiation:", evt%i_beam
        do i = 1, 2
           call evt%beam(i)%write (u, testflag=testflag)
        end do
        call write_separator (u)
        write (u, "(A)")  "... boosted to c.m.:"
        do i = 1, 2
           call evt%pi(i)%write (u, show_mass=show_mass, testflag=testflag)
        end do
     end if
     if (all (evt%i_radiated > 0)) then
        call write_separator (u)
        write (u, "(A,2(1x,I0))")  "Radiated particles, collinear:", &
             evt%i_radiated
        do i = 1, 2
           call evt%radiated(i)%write (u, testflag=testflag)
        end do
        call write_separator (u)
        write (u, "(A)")  "... boosted to c.m.:"
        do i = 1, 2
           call evt%ki(i)%write (u, show_mass=show_mass, testflag=testflag)
        end do
        call write_separator (u)
        write (u, "(A)")  "... with kT:"
        do i = 1, 2
           call evt%km(i)%write (u, show_mass=show_mass, testflag=testflag)
        end do
     end if
     if (all (evt%i_parton > 0)) then
        call write_separator (u)
        write (u, "(A,2(1x,I0))")  "Partons after radiation, collinear:", &
             evt%i_parton
        do i = 1, 2
           call evt%parton(i)%write (u, testflag=testflag)
        end do
        call write_separator (u)
        write (u, "(A)")  "... boosted to c.m.:"
        do i = 1, 2
           call evt%qi(i)%write (u, show_mass=show_mass, testflag=testflag)
        end do
        call write_separator (u)
        write (u, "(A)")  "... with qT, off-shell:"
        do i = 1, 2
           call evt%qm(i)%write (u, show_mass=show_mass, testflag=testflag)
        end do
        call write_separator (u)
        write (u, "(A)")  "... projected on-shell:"
        do i = 1, 2
           call evt%qo(i)%write (u, show_mass=show_mass, testflag=testflag)
        end do
        call write_separator (u)
     end if
     if (evt%particle_set_exists)  &
          call evt%particle_set%write &
          (u, summary = .true., compressed = .true., testflag = testflag)
     call write_separator (u)
   end subroutine evt_isr_epa_write
 
 @ %def evt_isr_epa_write
 @
 \subsection{Initialization}
 Manually import a random-number generator object.  This should be
 done only for testing purposes.  The standard procedure is to
 [[connect]] a process to an event transform; this will create an
 appropriate [[rng]] from the RNG factory in the process object.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: import_rng => evt_isr_epa_import_rng
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_import_rng (evt, rng)
     class(evt_isr_epa_t), intent(inout) :: evt
     class(rng_t), allocatable, intent(inout) :: rng
     call move_alloc (from = rng, to = evt%rng)
   end subroutine evt_isr_epa_import_rng
 
 @ %def evt_isr_epa_import_rng
 @ Set constant kinematics limits and initialize for ISR.  Note that [[sqrts]]
 is used only as the fallback value for [[q_max]].  The actual [[sqrts]] value
 for the transform object is inferred from the incoming particles, event by
 event.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: set_data_isr => evt_isr_epa_set_data_isr
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_set_data_isr (evt, sqrts, q_max, m)
     class(evt_isr_epa_t), intent(inout) :: evt
     real(default), intent(in) :: sqrts
     real(default), intent(in) :: q_max
     real(default), intent(in) :: m
     if (sqrts <= 0) then
        call msg_fatal ("ISR handler: sqrts value must be positive")
     end if
     if (q_max <= 0 .or. q_max > sqrts) then
        evt%isr_q_max = sqrts
     else
        evt%isr_q_max = q_max
     end if
     if (m > 0) then
        evt%isr_mass = m
     else
        call msg_fatal ("ISR handler: ISR_mass value must be positive")
     end if
     evt%isr_active = .true.
   end subroutine evt_isr_epa_set_data_isr
     
 @ %def evt_isr_epa_set_data_isr
 @ Set constant kinematics limits and initialize for EPA.  Note that [[sqrts]] is
 used only as the fallback value for [[q_max]].  The actual [[sqrts]]
 value for the transform object is inferred from the incoming
 particles, event by event.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: set_data_epa => evt_isr_epa_set_data_epa
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_set_data_epa (evt, sqrts, q_max, m)
     class(evt_isr_epa_t), intent(inout) :: evt
     real(default), intent(in) :: sqrts
     real(default), intent(in) :: q_max
     real(default), intent(in) :: m
     if (sqrts <= 0) then
        call msg_fatal ("EPA handler: sqrts value must be positive")
     end if
     if (q_max <= 0 .or. q_max > sqrts) then
        evt%epa_q_max = sqrts
     else
        evt%epa_q_max = q_max
     end if
     if (m > 0) then
        evt%epa_mass = m
     else
        call msg_fatal ("EPA handler: EPA_mass value must be positive")
     end if
     evt%epa_active = .true.
   end subroutine evt_isr_epa_set_data_epa
     
 @ %def evt_isr_epa_set_data_epa
 @
 \subsection{Fetch event data}
 Identify the radiated particles and the recoil momenta in the
 particle set.  Without much sophistication, start from the end and
 find particles with the ``remnant'' status.  Their parents should point to
 the recoiling parton.  If successful, set the particle indices in the
 [[evt]] object, for further processing.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure, private :: identify_radiated
 <<ISR/EPA handler: procedures>>=
   subroutine identify_radiated (evt)
     class(evt_isr_epa_t), intent(inout) :: evt
     integer :: i, k
     k = 2
     FIND_LAST_RADIATED: do i = evt%particle_set%get_n_tot (), 1, -1
        associate (prt => evt%particle_set%prt(i))
          if (prt%is_beam_remnant ()) then
             evt%i_radiated(k) = i
             evt%radiated(k) = prt
             k = k - 1
             if (k == 0)  exit FIND_LAST_RADIATED
          end if
        end associate
     end do FIND_LAST_RADIATED
     if (k /= 0)  call err_count
   contains
     subroutine err_count
       call evt%particle_set%write ()
       call msg_fatal ("ISR/EPA handler: &
            &event does not contain two radiated particles")
     end subroutine err_count
   end subroutine identify_radiated
   
 @ %def identify_radiated
 @ When the radiated particles are known, we can fetch their parent
 particles and ask for the other child, the incoming parton.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure, private :: identify_partons
 <<ISR/EPA handler: procedures>>=
   subroutine identify_partons (evt)
     class(evt_isr_epa_t), intent(inout) :: evt
     integer, dimension(:), allocatable :: parent, child
     integer :: i, j
     if (all (evt%i_radiated > 0)) then
        do i = 1, 2
           parent = evt%radiated(i)%get_parents ()
           if (size (parent) /= 1)  call err_mismatch
           evt%i_beam(i) = parent(1)
           evt%beam(i) = evt%particle_set%prt(parent(1))
           associate (prt => evt%beam(i))
             child = prt%get_children ()
             if (size (child) /= 2)  call err_mismatch
             do j = 1, 2
                if (child(j) /= evt%i_radiated(i)) then
                   evt%i_parton(i) = child(j)
                   evt%parton(i) = evt%particle_set%prt(child(j))
                end if
             end do
           end associate
        end do
     end if
   contains
     subroutine err_mismatch
       call evt%particle_set%write ()
       call msg_bug ("ISR/EPA handler: mismatch in parent-child relations")
     end subroutine err_mismatch
   end subroutine identify_partons
   
 @ %def identify_partons
 @ Check whether the radiated particle is a photon, or the incoming
 parton is a photon.  Then set the ISR/EPA switch appropriately, for
 each beam.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: check_radiation => evt_isr_epa_check_radiation
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_check_radiation (evt)
     class(evt_isr_epa_t), intent(inout) :: evt
     type(flavor_t) :: flv
     integer :: i
     do i = 1, 2
        flv = evt%radiated(i)%get_flv ()
        if (flv%get_pdg () == PHOTON) then
           if (evt%isr_active) then
              evt%rad_mode(i) = BEAM_RAD_ISR
           else
              call err_isr_init
           end if
        else
           flv = evt%parton(i)%get_flv ()
           if (flv%get_pdg () == PHOTON) then
              if (evt%epa_active) then
                 evt%rad_mode(i) = BEAM_RAD_EPA
              else
                 call err_epa_init
              end if
           else
              call err_no_photon
           end if
        end if
     end do
   contains
     subroutine err_isr_init
       call evt%particle_set%write ()
       call msg_fatal ("ISR/EPA handler: &
            &event contains radiated photon, but ISR is not initialized")
     end subroutine err_isr_init
     subroutine err_epa_init
       call evt%particle_set%write ()
       call msg_fatal ("ISR/EPA handler: &
            &event contains incoming photon, but EPA is not initialized")
     end subroutine err_epa_init
     subroutine err_no_photon
       call evt%particle_set%write ()
       call msg_fatal ("ISR/EPA handler: &
            &event does not appear to be ISR or EPA - missing photon")
     end subroutine err_no_photon
   end subroutine evt_isr_epa_check_radiation
   
 @ %def evt_isr_epa_check_radiation
 @ Internally set the appropriate parameters (ISR/EPA) for the two
 beams in the recoil mode.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: set_recoil_parameters => evt_isr_epa_set_recoil_parameters
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_set_recoil_parameters (evt)
     class(evt_isr_epa_t), intent(inout) :: evt
     integer :: i
     do i = 1, 2
        select case (evt%rad_mode(i))
        case (BEAM_RAD_ISR)
           evt%q_max(i) = evt%isr_q_max
           evt%m(i) = evt%isr_mass
        case (BEAM_RAD_EPA)
           evt%q_max(i) = evt%epa_q_max
           evt%m(i) = evt%epa_mass
        end select
     end do
   end subroutine evt_isr_epa_set_recoil_parameters
 
 @ %def evt_isr_epa_set_recoil_parameters
 @ Boost the particles that participate in ISR to their proper
 c.m.\ frame, copying the momenta to [[pi]], [[ki]], [[qi]].  Also
 assign [[sqrts]] properly.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure, private :: boost_to_cm
 <<ISR/EPA handler: procedures>>=
   subroutine boost_to_cm (evt)
     class(evt_isr_epa_t), intent(inout) :: evt
     type(vector4_t), dimension(2) :: p
     type(vector4_t), dimension(2) :: k
     type(vector4_t), dimension(2) :: q
     logical :: ok
     p = evt%beam%get_momentum ()
     k = evt%radiated%get_momentum ()
     q = evt%parton%get_momentum ()
     call initial_transformation (p, evt%sqrts, evt%lti, ok)
     if (.not. ok)  call err_non_collinear
     evt%pi = inverse (evt%lti) * p
     evt%ki = inverse (evt%lti) * k
     evt%qi = inverse (evt%lti) * q
   contains
     subroutine err_non_collinear
       call evt%particle_set%write ()
       call msg_fatal ("ISR/EPA handler: &
            &partons before radiation are not collinear")
     end subroutine err_non_collinear
   end subroutine boost_to_cm
 
 @ %def boost_to_cm    
 @ We can infer the $x$ and $\bar x$ values of the event by looking at
 the energy fractions of the radiated particles and incoming partons,
 respectively, relative to their 
 parents.  Of course, we must assume that they are all collinear, and
 that energy is conserved.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure, private :: infer_x
 <<ISR/EPA handler: procedures>>=
   subroutine infer_x (evt)
     class(evt_isr_epa_t), intent(inout) :: evt
     real(default) :: E_parent, E_radiated, E_parton
     integer :: i
     if (all (evt%i_radiated > 0)) then
        do i = 1, 2
           E_parent = energy (evt%pi(i))
           E_radiated = energy (evt%ki(i))
           E_parton = energy (evt%qi(i))
           if (E_parent > 0) then
              evt%xc(i) = E_parton / E_parent
              evt%xcb(i)= E_radiated / E_parent
           else
              call err_energy
           end if
        end do
     end if
   contains
     subroutine err_energy
       call evt%particle_set%write ()
       call msg_bug ("ISR/EPA handler: non-positive energy in splitting")
     end subroutine err_energy
   end subroutine infer_x
   
 @ %def infer_x
 @
 \subsection{Two-parton recoil}
 For transforming partons into recoil momenta, we make use of the
 routines in the [[recoil_kinematics]] module.  In addition to the
 collinear momenta, we use the $x$ energy fractions, and four numbers
 from the RNG.
 
 There is one subtle difference w.r.t.\ ISR case: the EPA mass
 parameter is multiplied by the energy fraction $x$, separately for
 each beam.  This is the effective lower $Q$ cutoff.
 
 For certain kinematics, close to the $Q_\text{max}$ endpoint, this may
 fail, and [[ok]] is set to false.  In that case, we should generate
 new recoil momenta for the same event.  This is handled by the generic
 unweighting procedure.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure, private :: generate_recoil => evt_generate_recoil
 <<ISR/EPA handler: procedures>>=
   subroutine evt_generate_recoil (evt, ok)
     class(evt_isr_epa_t), intent(inout) :: evt
     logical, intent(out) :: ok
     real(default), dimension(4) :: r
     real(default), dimension(2) :: m
     integer :: i
     call evt%rng%generate (r)
     do i = 1, 2
        select case (evt%rad_mode(i))
        case (BEAM_RAD_ISR);  m(i) = evt%m(i)
        case (BEAM_RAD_EPA);  m(i) = evt%xc(i) * evt%m(i)
        case default;         m(i) = 0
        end select
     end do
     call generate_recoil (evt%sqrts, evt%q_max, m, evt%xc, evt%xcb, r, &
          evt%km, evt%qm, evt%qo, ok)
   end subroutine evt_generate_recoil
 
 @ %def evt_generate_recoil
 @ Replace the collinear radiated (incoming) parton momenta by the
 momenta that we 
 have generated, respectively.  Recall that the recoil has been applied
 in the c.m.\ system of the partons before ISR, so we apply the stored
 Lorentz transformation to boost them to the lab frame.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure, private :: replace_radiated
   procedure, private :: replace_partons
 <<ISR/EPA handler: procedures>>=
   subroutine replace_radiated (evt)
     class(evt_isr_epa_t), intent(inout) :: evt
     integer :: i
     do i = 1, 2
        associate (prt => evt%particle_set%prt(evt%i_radiated(i)))
          call prt%set_momentum (evt%lti * evt%km(i))
        end associate
     end do
   end subroutine replace_radiated
 
   subroutine replace_partons (evt)
     class(evt_isr_epa_t), intent(inout) :: evt
     integer :: i
     do i = 1, 2
        associate (prt => evt%particle_set%prt(evt%i_parton(i)))
          call prt%set_momentum (evt%lti * evt%qo(i))
        end associate
     end do
   end subroutine replace_partons
 
 @ %def replace_radiated
 @ %def replace_partons
 @
 \subsection{Transform the event}
 Knowing the new incoming partons for the elementary process, we can
 make use of another procedure in [[recoil_kinematics]] to determine
 the Lorentz transformation that transforms the collinear frame into
 the frame with transverse momentum.  We apply this transformation,
 recursively, to all particles that originate from those incoming
 partons in the original particle set.
 
 We have to allow for the pre-ISR partons being not in their common
 c.m.\ frame.  Taking into account non-commutativity, we actually have
 to first transform the outgoing particles to that c.m.\ frame, then
 apply the recoil transformation, then boost back to the lab frame.
 
 The [[mask]] keep track of particles that we transform, just in case
 the parent-child tree is multiply connected.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: transform_outgoing => evt_transform_outgoing
 <<ISR/EPA handler: procedures>>=
   subroutine evt_transform_outgoing (evt)
     class(evt_isr_epa_t), intent(inout) :: evt
     logical, dimension(:), allocatable :: mask
     call recoil_transformation (evt%sqrts, evt%xc, evt%qo, evt%lto)
     evt%lt = evt%lti * evt%lto * inverse (evt%lti)
     allocate (mask (evt%particle_set%get_n_tot ()), source=.false.)
     call transform_children (evt%i_parton(1))
   contains
     recursive subroutine transform_children (i)
       integer, intent(in) :: i
       integer :: j, n_child, c
       integer, dimension(:), allocatable :: child
       child = evt%particle_set%prt(i)%get_children ()
       do j = 1, size (child)
          c = child(j)
          if (.not. mask(c)) then
             associate (prt => evt%particle_set%prt(c))
               call prt%set_momentum (evt%lt * prt%get_momentum ())
               mask(c) = .true.
               call transform_children (c)
             end associate
          end if
       end do
     end subroutine transform_children
   end subroutine evt_transform_outgoing
   
 @ %def evt_transform_outgoing
 @
 \subsection{Implemented methods}
 Here we take the particle set from the previous event transform and
 copy it, then generate the transverse momentum for the radiated
 particles and for 
 the incoming partons.  If this fails (rarely, for large $p_T$),
 return zero for the probability, to trigger another try.
 
 NOTE: The boost for the initial partonic system, if not in the
 c.m.\ frame, has not been implemented yet.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: generate_weighted => &
        evt_isr_epa_generate_weighted
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_generate_weighted (evt, probability)
     class(evt_isr_epa_t), intent(inout) :: evt
     real(default), intent(inout) :: probability
     logical :: valid
     call evt%particle_set%final ()
     evt%particle_set = evt%previous%particle_set
     evt%particle_set_exists = .true.
     select case (evt%mode)
     case (ISR_TRIVIAL_COLLINEAR)
        probability = 1
        valid = .true.
     case (ISR_PAIR_RECOIL)
        call evt%identify_radiated ()
        call evt%identify_partons ()
        call evt%check_radiation ()
        call evt%set_recoil_parameters ()
        call evt%boost_to_cm ()
        call evt%infer_x ()
        call evt%generate_recoil (valid)
        if (valid) then
           probability = 1
        else
           probability = 0
        end if
     case default
        call msg_bug ("ISR/EPA handler: generate weighted: unsupported mode")
     end select
     evt%particle_set_exists = .false.
   end subroutine evt_isr_epa_generate_weighted
 
 @ %def evt_isr_epa_generate_weighted
 @ Insert the generated radiated particles and incoming partons with
 $p_T$ in their respective places.
 
 The factorization parameters are irrelevant.
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: make_particle_set => &
        evt_isr_epa_make_particle_set
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_make_particle_set &
        (evt, factorization_mode, keep_correlations, r)
     class(evt_isr_epa_t), intent(inout) :: evt
     integer, intent(in) :: factorization_mode
     logical, intent(in) :: keep_correlations
     real(default), dimension(:), intent(in), optional :: r
     select case (evt%mode)
     case (ISR_TRIVIAL_COLLINEAR)
     case (ISR_PAIR_RECOIL)
        call evt%replace_radiated ()
        call evt%replace_partons ()
        call evt%transform_outgoing ()
     case default
        call msg_bug ("ISR/EPA handler: make particle set: unsupported mode")
     end select
     evt%particle_set_exists = .true.
   end subroutine evt_isr_epa_make_particle_set
 
 @ %def event_isr_epa_handler_make_particle_set
 @
 <<ISR/EPA handler: evt isr: TBP>>=
   procedure :: prepare_new_event => &
        evt_isr_epa_prepare_new_event
 <<ISR/EPA handler: procedures>>=
   subroutine evt_isr_epa_prepare_new_event (evt, i_mci, i_term)
     class(evt_isr_epa_t), intent(inout) :: evt
     integer, intent(in) :: i_mci, i_term
     call evt%reset ()
   end subroutine evt_isr_epa_prepare_new_event
 
 @ %def evt_isr_epa_prepare_new_event
 @
 \subsection{Unit tests: ISR}
 Test module, followed by the corresponding implementation module.
 
 This test module differs from most of the other test modules, since it
 contains two test subroutines: one for ISR and one for EPA below.
 <<[[isr_epa_handler_ut.f90]]>>=
 <<File header>>
 
 module isr_epa_handler_ut
   use unit_tests
   use isr_epa_handler_uti
 
 <<Standard module head>>
 
 <<ISR/EPA handler: public test>>
 
 contains
 
 <<ISR/EPA handler: test driver>>
 
 end module isr_epa_handler_ut
 @ %def isr_epa_handler_ut
 @
 <<[[isr_epa_handler_uti.f90]]>>=
 <<File header>>
 
 module isr_epa_handler_uti
 
 <<Use kinds>>
 <<Use strings>>
   use format_utils, only: write_separator
   use os_interface
   use lorentz, only: vector4_t, vector4_moving, operator(*)
   use rng_base, only: rng_t
   use models, only: syntax_model_file_init, syntax_model_file_final
   use models, only: model_list_t, model_t
   use particles, only: particle_set_t
 
   use event_transforms
   use isr_epa_handler, only: evt_isr_epa_t
 
   use rng_base_ut, only: rng_test_t
 
 <<Standard module head>>
 
 <<ISR/EPA handler: test declarations>>
 
 contains
 
 <<ISR/EPA handler: tests>>
 
 end module isr_epa_handler_uti
 
 @ %def isr_epa_handler_uti
 @ API: driver for the unit tests below.
 <<ISR/EPA handler: public test>>=
   public :: isr_handler_test
 <<ISR/EPA handler: test driver>>=
   subroutine isr_handler_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<ISR/EPA handler: execute ISR tests>>
   end subroutine isr_handler_test
 
 @ %def isr_handler_test
 @
 \subsubsection{Trivial case}
 Handle photons resulting from ISR radiation.  This test is for the
 trivial case where the event is kept collinear.
 <<ISR/EPA handler: execute ISR tests>>=
   call test (isr_handler_1, "isr_handler_1", &
        "collinear case, no modification", &
        u, results)
 <<ISR/EPA handler: test declarations>>=
   public :: isr_handler_1
 <<ISR/EPA handler: tests>>=
   subroutine isr_handler_1 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(particle_set_t) :: pset
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(evt_trivial_t), target :: evt_trivial
     type(evt_isr_epa_t), target :: evt_isr_epa
     type(vector4_t), dimension(8) :: p
     real(default) :: sqrts
     real(default), dimension(2) :: x, xb
     real(default) :: probability
 
     write (u, "(A)")  "* Test output: isr_handler_1"
     write (u, "(A)")  "*   Purpose: apply photon handler trivially (no-op)"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM"), var_str ("SM.mdl"), &
          os_data, model)
 
     write (u, "(A)")  "* Initialize particle set"
     write (u, "(A)")
     
     call pset%init_direct (n_beam = 2, n_in = 2, n_rem = 2, n_vir = 0, n_out = 2, &
          pdg = [11, -11, 11, -11, 22, 22, 13, -13], model = model)
 
     sqrts = 100._default
     x = [0.6_default, 0.9_default]
     xb= 1 - x
 
     p(1) = vector4_moving (sqrts/2, sqrts/2, 3)
     p(2) = vector4_moving (sqrts/2,-sqrts/2, 3)
     p(3:4) = x * p(1:2)
     p(5:6) = xb  * p(1:2)
     p(7:8) = p(3:4)
 
     call pset%set_momentum (p, on_shell = .false.)
     
     write (u, "(A)")  "* Fill trivial event transform"
     write (u, "(A)")
 
     call evt_trivial%reset ()
     call evt_trivial%set_particle_set (pset, 1, 1)
     call evt_trivial%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Initialize ISR handler transform"
     write (u, "(A)")
     
     evt_trivial%next => evt_isr_epa
     evt_isr_epa%previous => evt_trivial
     
     call evt_isr_epa%write (u)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill ISR handler transform"
     write (u, "(A)")
     
     call evt_isr_epa%prepare_new_event (1, 1)
     call evt_isr_epa%generate_weighted (probability)
     call evt_isr_epa%make_particle_set (0, .false.)
     
     call evt_isr_epa%write (u)
     
     write (u, "(A)")
     write (u, "(A,1x,F8.5)")  "Event probability =", probability
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_isr_epa%final ()
     call evt_trivial%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: isr_handler_1"
 
   end subroutine isr_handler_1
 
 @ %def isr_handler_1
 @
 \subsubsection{Photon pair with recoil}
 Handle photons resulting from ISR radiation.  This test invokes the
 two-photon recoil mechanism.  Both photons acquire transverse
 momentum, the parton momenta recoil, such that total energy-momentum
 is conserved, and all outgoing photons and partons are on-shell
 (massless).
 <<ISR/EPA handler: execute ISR tests>>=
   call test (isr_handler_2, "isr_handler_2", &
        "two-photon recoil", &
        u, results)
 <<ISR/EPA handler: test declarations>>=
   public :: isr_handler_2
 <<ISR/EPA handler: tests>>=
   subroutine isr_handler_2 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(particle_set_t) :: pset
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(evt_trivial_t), target :: evt_trivial
     type(evt_isr_epa_t), target :: evt_isr_epa
     type(vector4_t), dimension(8) :: p
     real(default) :: sqrts
     real(default), dimension(2) :: x, xb
     class(rng_t), allocatable :: rng
     real(default) :: probability
 
     write (u, "(A)")  "* Test output: isr_handler_2"
     write (u, "(A)")  "*   Purpose: apply photon handler with two-photon recoil"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM"), var_str ("SM.mdl"), &
          os_data, model)
 
     write (u, "(A)")  "* Initialize particle set"
     write (u, "(A)")
     
     call pset%init_direct (n_beam = 2, n_in = 2, n_rem = 2, n_vir = 0, n_out = 2, &
          pdg = [11, -11, 11, -11, 22, 22, 13, -13], model = model)
 
     sqrts = 100._default
     x = [0.6_default, 0.9_default]
     xb= 1 - x
 
     p(1) = vector4_moving (sqrts/2, sqrts/2, 3)
     p(2) = vector4_moving (sqrts/2,-sqrts/2, 3)
     p(3:4) = x * p(1:2)
     p(5:6) = xb  * p(1:2)
     p(7:8) = p(3:4)
 
     call pset%set_momentum (p, on_shell = .false.)
     
     write (u, "(A)")  "* Fill trivial event transform"
     write (u, "(A)")
 
     call evt_trivial%reset ()
     call evt_trivial%set_particle_set (pset, 1, 1)
     call evt_trivial%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Initialize ISR handler transform"
     write (u, "(A)")
     
     evt_trivial%next => evt_isr_epa
     evt_isr_epa%previous => evt_trivial
     
     call evt_isr_epa%set_mode_string (var_str ("recoil"))
     call evt_isr_epa%set_data_isr ( &
          sqrts = sqrts, &
          q_max = sqrts, &
          m = 511.e-3_default &
          )
 
     allocate (rng_test_t :: rng)
     call rng%init (3)  ! default would produce pi for azimuthal angle
     call evt_isr_epa%import_rng (rng)
 
     call evt_isr_epa%write (u, testflag=.true.)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill ISR handler transform"
     write (u, "(A)")
     
     call evt_isr_epa%prepare_new_event (1, 1)
     call evt_isr_epa%generate_weighted (probability)
     call evt_isr_epa%make_particle_set (0, .false.)
     
     call evt_isr_epa%write (u, testflag=.true.)
     
     write (u, "(A)")
     write (u, "(A,1x,F8.5)")  "Event probability =", probability
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_isr_epa%final ()
     call evt_trivial%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: isr_handler_2"
 
   end subroutine isr_handler_2
 
 @ %def isr_handler_2
 @
 \subsubsection{Boosted beams}
 Handle photons resulting from ISR radiation.  This test invokes the
 two-photon recoil mechanism, in the case that the partons before ISR
 are not in their c.m.\ frame (but collinear).
 <<ISR/EPA handler: execute ISR tests>>=
   call test (isr_handler_3, "isr_handler_3", &
        "two-photon recoil with boost", &
        u, results)
 <<ISR/EPA handler: test declarations>>=
   public :: isr_handler_3
 <<ISR/EPA handler: tests>>=
   subroutine isr_handler_3 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(particle_set_t) :: pset
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(evt_trivial_t), target :: evt_trivial
     type(evt_isr_epa_t), target :: evt_isr_epa
     type(vector4_t), dimension(8) :: p
     real(default) :: sqrts
     real(default), dimension(2) :: x0
     real(default), dimension(2) :: x, xb
     class(rng_t), allocatable :: rng
     real(default) :: probability
 
     write (u, "(A)")  "* Test output: isr_handler_3"
     write (u, "(A)")  "*   Purpose: apply photon handler for boosted beams &
          &and two-photon recoil"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM"), var_str ("SM.mdl"), &
          os_data, model)
 
     write (u, "(A)")  "* Initialize particle set"
     write (u, "(A)")
     
     call pset%init_direct (n_beam = 2, n_in = 2, n_rem = 2, n_vir = 0, n_out = 2, &
          pdg = [11, -11, 11, -11, 22, 22, 13, -13], model = model)
 
     write (u, "(A)")  "* Event data"
     write (u, "(A)")
 
     sqrts = 100._default
     write (u, "(A,2(1x,F12.7))")  "sqrts   =", sqrts
 
     x0 = [0.9_default, 0.4_default]
     write (u, "(A,2(1x,F12.7))")  "x0      =", x0
 
     write (u, "(A)")
     write (u, "(A,2(1x,F12.7))")  "sqs_hat =", sqrts * sqrt (product (x0))
 
     x = [0.6_default, 0.9_default]
     xb= 1 - x
     write (u, "(A,2(1x,F12.7))")  "x       =", x
 
     write (u, "(A)")
     write (u, "(A,2(1x,F12.7))")  "x0 * x  =", x0 * x
 
     p(1) = x0(1) * vector4_moving (sqrts/2, sqrts/2, 3)
     p(2) = x0(2) * vector4_moving (sqrts/2,-sqrts/2, 3)
     p(3:4) = x * p(1:2)
     p(5:6) = xb  * p(1:2)
     p(7:8) = p(3:4)
 
     call pset%set_momentum (p, on_shell = .false.)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill trivial event transform"
     write (u, "(A)")
 
     call evt_trivial%reset ()
     call evt_trivial%set_particle_set (pset, 1, 1)
     call evt_trivial%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Initialize ISR handler transform"
     write (u, "(A)")
     
     evt_trivial%next => evt_isr_epa
     evt_isr_epa%previous => evt_trivial
     
     call evt_isr_epa%set_mode_string (var_str ("recoil"))
     call evt_isr_epa%set_data_isr ( &
          sqrts = sqrts, &
          q_max = sqrts, &
          m = 511.e-3_default &
          )
 
     allocate (rng_test_t :: rng)
     call rng%init (3)  ! default would produce pi for azimuthal angle
     call evt_isr_epa%import_rng (rng)
 
     call evt_isr_epa%write (u, testflag=.true.)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill ISR handler transform"
     write (u, "(A)")
     
     call evt_isr_epa%prepare_new_event (1, 1)
     call evt_isr_epa%generate_weighted (probability)
     call evt_isr_epa%make_particle_set (0, .false.)
     
     call evt_isr_epa%write (u, testflag=.true.)
     
     write (u, "(A)")
     write (u, "(A,1x,F8.5)")  "Event probability =", probability
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_isr_epa%final ()
     call evt_trivial%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: isr_handler_3"
 
   end subroutine isr_handler_3
 
 @ %def isr_handler_3
 @
 \subsection{Unit tests: EPA}
 API: Extra driver for the unit tests below.
 <<ISR/EPA handler: public test>>=
   public :: epa_handler_test
 <<ISR/EPA handler: test driver>>=
   subroutine epa_handler_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<ISR/EPA handler: execute EPA tests>>
   end subroutine epa_handler_test
 
 @ %def epa_handler_test
 @
 \subsubsection{Trivial case}
 Handle events resulting from the EPA approximation.  This test is for the
 trivial case where the event is kept collinear.
 <<ISR/EPA handler: execute EPA tests>>=
   call test (epa_handler_1, "epa_handler_1", &
        "collinear case, no modification", &
        u, results)
 <<ISR/EPA handler: test declarations>>=
   public :: epa_handler_1
 <<ISR/EPA handler: tests>>=
   subroutine epa_handler_1 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(particle_set_t) :: pset
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(evt_trivial_t), target :: evt_trivial
     type(evt_isr_epa_t), target :: evt_isr_epa
     type(vector4_t), dimension(8) :: p
     real(default) :: sqrts
     real(default), dimension(2) :: x, xb
     real(default) :: probability
 
     write (u, "(A)")  "* Test output: epa_handler_1"
     write (u, "(A)")  "*   Purpose: apply beam handler trivially (no-op)"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM"), var_str ("SM.mdl"), &
          os_data, model)
 
     write (u, "(A)")  "* Initialize particle set"
     write (u, "(A)")
     
     call pset%init_direct &
          (n_beam = 2, n_in = 2, n_rem = 2, n_vir = 0, n_out = 2, &
          pdg = [11, -11, 22, 22, 11, -11, 13, -13], &
          model = model)
 
     sqrts = 100._default
     x = [0.6_default, 0.9_default]
     xb= 1 - x
 
     p(1) = vector4_moving (sqrts/2, sqrts/2, 3)
     p(2) = vector4_moving (sqrts/2,-sqrts/2, 3)
     p(3:4) = x * p(1:2)
     p(5:6) = xb  * p(1:2)
     p(7:8) = p(3:4)
 
     call pset%set_momentum (p, on_shell = .false.)
     
     write (u, "(A)")  "* Fill trivial event transform"
     write (u, "(A)")
 
     call evt_trivial%reset ()
     call evt_trivial%set_particle_set (pset, 1, 1)
     call evt_trivial%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Initialize EPA handler transform"
     write (u, "(A)")
     
     evt_trivial%next => evt_isr_epa
     evt_isr_epa%previous => evt_trivial
     
     call evt_isr_epa%write (u)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill EPA handler transform"
     write (u, "(A)")
     
     call evt_isr_epa%prepare_new_event (1, 1)
     call evt_isr_epa%generate_weighted (probability)
     call evt_isr_epa%make_particle_set (0, .false.)
     
     call evt_isr_epa%write (u)
     
     write (u, "(A)")
     write (u, "(A,1x,F8.5)")  "Event probability =", probability
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_isr_epa%final ()
     call evt_trivial%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: epa_handler_1"
 
   end subroutine epa_handler_1
 
 @ %def epa_handler_1
 @
 \subsubsection{Beam pair with recoil}
 Handle beams resulting from the EPA approximation.  This test invokes the
 two-beam recoil mechanism.  Both beam remnants acquire transverse
 momentum, the photon momenta recoil, such that total energy-momentum
 is conserved, and all outgoing beam remnants and photons are on-shell
 (massless).
 <<ISR/EPA handler: execute EPA tests>>=
   call test (epa_handler_2, "epa_handler_2", &
        "two-beam recoil", &
        u, results)
 <<ISR/EPA handler: test declarations>>=
   public :: epa_handler_2
 <<ISR/EPA handler: tests>>=
   subroutine epa_handler_2 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(particle_set_t) :: pset
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(evt_trivial_t), target :: evt_trivial
     type(evt_isr_epa_t), target :: evt_isr_epa
     type(vector4_t), dimension(8) :: p
     real(default) :: sqrts
     real(default), dimension(2) :: x, xb
     class(rng_t), allocatable :: rng
     real(default) :: probability
 
     write (u, "(A)")  "* Test output: epa_handler_2"
     write (u, "(A)")  "*   Purpose: apply beam handler with two-beam recoil"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM"), var_str ("SM.mdl"), &
          os_data, model)
 
     write (u, "(A)")  "* Initialize particle set"
     write (u, "(A)")
     
     call pset%init_direct (n_beam = 2, n_in = 2, n_rem = 2, n_vir = 0, n_out = 2, &
          pdg = [11, -11, 22, 22, 11, -11, 13, -13], model = model)
 
     sqrts = 100._default
     x = [0.6_default, 0.9_default]
     xb= 1 - x
 
     p(1) = vector4_moving (sqrts/2, sqrts/2, 3)
     p(2) = vector4_moving (sqrts/2,-sqrts/2, 3)
     p(3:4) = x * p(1:2)
     p(5:6) = xb  * p(1:2)
     p(7:8) = p(3:4)
 
     call pset%set_momentum (p, on_shell = .false.)
     
     write (u, "(A)")  "* Fill trivial event transform"
     write (u, "(A)")
 
     call evt_trivial%reset ()
     call evt_trivial%set_particle_set (pset, 1, 1)
     call evt_trivial%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Initialize EPA handler transform"
     write (u, "(A)")
     
     evt_trivial%next => evt_isr_epa
     evt_isr_epa%previous => evt_trivial
     
     call evt_isr_epa%set_mode_string (var_str ("recoil"))
     call evt_isr_epa%set_data_epa ( &
          sqrts = sqrts, &
          q_max = sqrts, &
          m = 511.e-3_default &
          )
 
     allocate (rng_test_t :: rng)
     call rng%init (3)  ! default would produce pi for azimuthal angle
     call evt_isr_epa%import_rng (rng)
 
     call evt_isr_epa%write (u, testflag=.true.)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill EPA handler transform"
     write (u, "(A)")
     
     call evt_isr_epa%prepare_new_event (1, 1)
     call evt_isr_epa%generate_weighted (probability)
     call evt_isr_epa%make_particle_set (0, .false.)
     
     call evt_isr_epa%write (u, testflag=.true.)
     
     write (u, "(A)")
     write (u, "(A,1x,F8.5)")  "Event probability =", probability
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_isr_epa%final ()
     call evt_trivial%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: epa_handler_2"
 
   end subroutine epa_handler_2
 
 @ %def epa_handler_2
 @
 \subsubsection{Boosted beams}
 Handle radiated beam remnants resulting from EPA radiation.  This test
 invokes the two-beam recoil mechanism, in the case that the partons
 before EPA are not in their c.m.\ frame (but collinear).
 <<ISR/EPA handler: execute EPA tests>>=
   call test (epa_handler_3, "epa_handler_3", &
        "two-beam recoil with boost", &
        u, results)
 <<ISR/EPA handler: test declarations>>=
   public :: epa_handler_3
 <<ISR/EPA handler: tests>>=
   subroutine epa_handler_3 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(particle_set_t) :: pset
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(evt_trivial_t), target :: evt_trivial
     type(evt_isr_epa_t), target :: evt_isr_epa
     type(vector4_t), dimension(8) :: p
     real(default) :: sqrts
     real(default), dimension(2) :: x0
     real(default), dimension(2) :: x, xb
     class(rng_t), allocatable :: rng
     real(default) :: probability
 
     write (u, "(A)")  "* Test output: epa_handler_3"
     write (u, "(A)")  "*   Purpose: apply beam handler for boosted beams &
          &and two-beam recoil"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM"), var_str ("SM.mdl"), &
          os_data, model)
 
     write (u, "(A)")  "* Initialize particle set"
     write (u, "(A)")
     
     call pset%init_direct (n_beam = 2, n_in = 2, n_rem = 2, n_vir = 0, n_out = 2, &
          pdg = [11, -11, 22, 22, 11, -11, 13, -13], model = model)
 
     write (u, "(A)")  "* Event data"
     write (u, "(A)")
 
     sqrts = 100._default
     write (u, "(A,2(1x,F12.7))")  "sqrts   =", sqrts
 
     x0 = [0.9_default, 0.4_default]
     write (u, "(A,2(1x,F12.7))")  "x0      =", x0
 
     write (u, "(A)")
     write (u, "(A,2(1x,F12.7))")  "sqs_hat =", sqrts * sqrt (product (x0))
 
     x = [0.6_default, 0.9_default]
     xb= 1 - x
     write (u, "(A,2(1x,F12.7))")  "x       =", x
 
     write (u, "(A)")
     write (u, "(A,2(1x,F12.7))")  "x0 * x  =", x0 * x
 
     p(1) = x0(1) * vector4_moving (sqrts/2, sqrts/2, 3)
     p(2) = x0(2) * vector4_moving (sqrts/2,-sqrts/2, 3)
     p(3:4) = x * p(1:2)
     p(5:6) = xb  * p(1:2)
     p(7:8) = p(3:4)
 
     call pset%set_momentum (p, on_shell = .false.)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill trivial event transform"
     write (u, "(A)")
 
     call evt_trivial%reset ()
     call evt_trivial%set_particle_set (pset, 1, 1)
     call evt_trivial%write (u)
     call write_separator (u, 2)
 
     write (u, "(A)")
     write (u, "(A)")  "* Initialize EPA handler transform"
     write (u, "(A)")
     
     evt_trivial%next => evt_isr_epa
     evt_isr_epa%previous => evt_trivial
     
     call evt_isr_epa%set_mode_string (var_str ("recoil"))
     call evt_isr_epa%set_data_epa ( &
          sqrts = sqrts, &
          q_max = sqrts, &
          m = 511.e-3_default &
          )
 
     allocate (rng_test_t :: rng)
     call rng%init (3)  ! default would produce pi for azimuthal angle
     call evt_isr_epa%import_rng (rng)
 
     call evt_isr_epa%write (u, testflag=.true.)
     
     write (u, "(A)")
     write (u, "(A)")  "* Fill EPA handler transform"
     write (u, "(A)")
     
     call evt_isr_epa%prepare_new_event (1, 1)
     call evt_isr_epa%generate_weighted (probability)
     call evt_isr_epa%make_particle_set (0, .false.)
     
     call evt_isr_epa%write (u, testflag=.true.)
     
     write (u, "(A)")
     write (u, "(A,1x,F8.5)")  "Event probability =", probability
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_isr_epa%final ()
     call evt_trivial%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: epa_handler_3"
 
   end subroutine epa_handler_3
 
 @ %def epa_handler_3
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Decays}
 <<[[decays.f90]]>>=
 <<File header>>
 
 module decays
 
 <<Use kinds>>
 <<Use strings>>
   use io_units
   use format_utils, only: write_indent, write_separator
   use format_defs, only: FMT_15
   use numeric_utils
   use diagnostics
   use flavors
   use helicities
   use quantum_numbers
   use interactions
   use evaluators
   use variables, only: var_list_t
   use model_data
   use rng_base
   use selectors
   use parton_states
   use process, only: process_t
   use instances, only: process_instance_t, pacify
   use process_stacks
   use event_transforms
 
 <<Standard module head>>
 
 <<Decays: public>>
 
 <<Decays: types>>
 
 <<Decays: interfaces>>
 
 contains
 
 <<Decays: procedures>>
 
 end module decays
 
 @ %def decays
 @
 \subsection{Final-State Particle Configuration}
 A final-state particle may be either stable or unstable.  Here is an
 empty abstract type as the parent of both, with holds just the flavor
 information.
 <<Decays: types>>=
   type, abstract :: any_config_t
      private
    contains
    <<Decays: any config: TBP>>
   end type any_config_t
 
 @ %def any_config_t
 @ Finalizer, depends on the implementation.
 <<Decays: any config: TBP>>=
   procedure (any_config_final), deferred :: final
 <<Decays: interfaces>>=
   interface
      subroutine any_config_final (object)
        import
        class(any_config_t), intent(inout) :: object
      end subroutine any_config_final
   end interface
 
 @ %def any_config_final
 @ The output is also deferred:
 <<Decays: any config: TBP>>=
   procedure (any_config_write), deferred :: write
 <<Decays: interfaces>>=
   interface
      subroutine any_config_write (object, unit, indent, verbose)
        import
        class(any_config_t), intent(in) :: object
        integer, intent(in), optional :: unit, indent
        logical, intent(in), optional :: verbose
      end subroutine any_config_write
   end interface
 
 @ %def any_config_write
 @ This is a container for a stable or unstable particle configurator.
 We need this wrapper for preparing arrays that mix stable and unstable
 particles.
 <<Decays: types>>=
   type :: particle_config_t
      private
      class(any_config_t), allocatable :: c
   end type particle_config_t
 
 @ %def particle_config_t
 @
 \subsection{Final-State Particle}
 In theory, for the particle instance we only need to consider the
 unstable case.  However, it is more straightforward to treat
 configuration and instance on the same footing, and to introduce a
 wrapper for particle objects as above.  This also works
 around a compiler bug in gfortran.
 <<Decays: types>>=
   type, abstract :: any_t
      private
    contains
    <<Decays: any: TBP>>
   end type any_t
 
 @ %def any_t
 @ Finalizer, depends on the implementation.
 <<Decays: any: TBP>>=
   procedure (any_final), deferred :: final
 <<Decays: interfaces>>=
   interface
      subroutine any_final (object)
        import
        class(any_t), intent(inout) :: object
      end subroutine any_final
   end interface
 
 @ %def any_final
 @ The output is also deferred:
 <<Decays: any: TBP>>=
   procedure (any_write), deferred :: write
 <<Decays: interfaces>>=
   interface
      subroutine any_write (object, unit, indent)
        import
        class(any_t), intent(in) :: object
        integer, intent(in), optional :: unit, indent
      end subroutine any_write
   end interface
 
 @ %def any_write
 @ This is a container for a stable or unstable outgoing particle.
 We need this wrapper for preparing arrays that mix stable and unstable
 particles.
 <<Decays: types>>=
   type :: particle_out_t
      private
      class(any_t), allocatable :: c
   end type particle_out_t
 
 @ %def particle_config_t
 @
 \subsection{Decay Term Configuration}
 A decay term is a distinct final state, corresponding to a process
 term.  Each decay process may give rise to several terms with,
 possibly, differing flavor content.
 <<Decays: types>>=
   type :: decay_term_config_t
      private
      type(particle_config_t), dimension(:), allocatable :: prt
    contains
    <<Decays: decay term config: TBP>>
   end type decay_term_config_t
 
 @ %def decay_term_config_t
 @ Finalizer, recursive.
 <<Decays: decay term config: TBP>>=
   procedure :: final => decay_term_config_final
 <<Decays: procedures>>=
   recursive subroutine decay_term_config_final (object)
     class(decay_term_config_t), intent(inout) :: object
     integer :: i
     if (allocated (object%prt)) then
        do i = 1, size (object%prt)
           if (allocated (object%prt(i)%c))  call object%prt(i)%c%final ()
        end do
     end if
   end subroutine decay_term_config_final
 
 @ %def decay_term_config_final
 @ Output, with optional indentation
 <<Decays: decay term config: TBP>>=
   procedure :: write => decay_term_config_write
 <<Decays: procedures>>=
   recursive subroutine decay_term_config_write (object, unit, indent, verbose)
     class(decay_term_config_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent
     logical, intent(in), optional :: verbose
     integer :: i, j, u, ind
     logical :: verb
     u = given_output_unit (unit)
     ind = 0;  if (present (indent))  ind = indent
     verb = .true.;  if (present (verbose))  verb = verbose
     call write_indent (u, ind)
     write (u, "(1x,A)", advance="no")  "Final state:"
     do i = 1, size (object%prt)
        select type (prt_config => object%prt(i)%c)
        type is (stable_config_t)
           write (u, "(1x,A)", advance="no") &
                char (prt_config%flv(1)%get_name ())
           do j = 2, size (prt_config%flv)
              write (u, "(':',A)", advance="no") &
                   char (prt_config%flv(j)%get_name ())
           end do
        type is (unstable_config_t)
           write (u, "(1x,A)", advance="no") &
                char (prt_config%flv%get_name ())
        end select
     end do
     write (u, *)
     if (verb) then
        do i = 1, size (object%prt)
           call object%prt(i)%c%write (u, ind)
        end do
     end if
   end subroutine decay_term_config_write
 
 @ %def decay_term_config_write
 @ Initialize, given a set of flavors.  For each flavor, we must indicate
 whether the particle is stable.  The second index of the flavor array runs
 over alternatives for each decay product; alternatives are allowed only if the
 decay product is itself stable.
 <<Decays: decay term config: TBP>>=
   procedure :: init => decay_term_config_init
 <<Decays: procedures>>=
   recursive subroutine decay_term_config_init &
        (term, flv, stable, model, process_stack, var_list)
     class(decay_term_config_t), intent(out) :: term
     type(flavor_t), dimension(:,:), intent(in) :: flv
     logical, dimension(:), intent(in) :: stable
     class(model_data_t), intent(in), target :: model
     type(process_stack_t), intent(in), optional :: process_stack
     type(var_list_t), intent(in), optional :: var_list
     type(string_t), dimension(:), allocatable :: decay
     integer :: i
     allocate (term%prt (size (flv, 1)))
     do i = 1, size (flv, 1)
        associate (prt => term%prt(i))
          if (stable(i)) then
             allocate (stable_config_t :: prt%c)
          else
             allocate (unstable_config_t :: prt%c)
          end if
          select type (prt_config => prt%c)
          type is (stable_config_t)
             call prt_config%init (flv(i,:))
          type is (unstable_config_t)
             if (all (flv(i,:) == flv(i,1))) then
                call prt_config%init (flv(i,1))
                call flv(i,1)%get_decays (decay)
                call prt_config%init_decays &
                     (decay, model, process_stack, var_list)
             else
                call prt_config%write ()
                call msg_fatal ("Decay configuration: &
                     &unstable product must be unique")
             end if
          end select
        end associate
     end do
   end subroutine decay_term_config_init
 
 @ %def decay_term_config_init
 @ Recursively compute widths and branching ratios for all unstable particles.
 <<Decays: decay term config: TBP>>=
   procedure :: compute => decay_term_config_compute
 <<Decays: procedures>>=
   recursive subroutine decay_term_config_compute (term)
     class(decay_term_config_t), intent(inout) :: term
     integer :: i
     do i = 1, size (term%prt)
        select type (unstable_config => term%prt(i)%c)
        type is (unstable_config_t)
           call unstable_config%compute ()
        end select
     end do
   end subroutine decay_term_config_compute
 
 @ %def decay_term_config_compute
 @
 \subsection{Decay Term}
 A decay term instance is selected when we generate an event for the associated
 process instance.  When evaluated, it triggers further decays down the chain.
 
 Only unstable products are allocated as child particles.
 <<Decays: types>>=
   type :: decay_term_t
      private
      type(decay_term_config_t), pointer :: config => null ()
      type(particle_out_t), dimension(:), allocatable :: particle_out
    contains
    <<Decays: decay term: TBP>>
   end type decay_term_t
 
 @ %def decay_term_t
 @ Finalizer.
 <<Decays: decay term: TBP>>=
   procedure :: final => decay_term_final
 <<Decays: procedures>>=
   recursive subroutine decay_term_final (object)
     class(decay_term_t), intent(inout) :: object
     integer :: i
     if (allocated (object%particle_out)) then
        do i = 1, size (object%particle_out)
           call object%particle_out(i)%c%final ()
        end do
     end if
   end subroutine decay_term_final
 
 @ %def decay_term_final
 @ Output.
 <<Decays: decay term: TBP>>=
   procedure :: write => decay_term_write
 <<Decays: procedures>>=
   recursive subroutine decay_term_write (object, unit, indent)
     class(decay_term_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent
     integer :: i, u, ind
     u = given_output_unit (unit)
     ind = 0;  if (present (indent))  ind = indent
     call object%config%write (u, ind, verbose = .false.)
     do i = 1, size (object%particle_out)
        call object%particle_out(i)%c%write (u, ind)
     end do
   end subroutine decay_term_write
 
 @ %def decay_term_write
 @ Recursively write the embedded process instances.
 <<Decays: decay term: TBP>>=
   procedure :: write_process_instances => decay_term_write_process_instances
 <<Decays: procedures>>=
   recursive subroutine decay_term_write_process_instances (term, unit, verbose)
     class(decay_term_t), intent(in) :: term
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose
     integer :: i
     do i = 1, size (term%particle_out)
        select type (unstable => term%particle_out(i)%c)
        type is (unstable_t)
           call unstable%write_process_instances (unit, verbose)
        end select
     end do
   end subroutine decay_term_write_process_instances
 
 @ %def decay_term_write_process_instances
 @ Initialization, using the configuration object.  We allocate
 particle objects in parallel to the particle configuration objects
 which we use to initialize them, one at a time.
 <<Decays: decay term: TBP>>=
   procedure :: init => decay_term_init
 <<Decays: procedures>>=
   recursive subroutine decay_term_init (term, config)
     class(decay_term_t), intent(out) :: term
     type(decay_term_config_t), intent(in), target :: config
     integer :: i
     term%config => config
     allocate (term%particle_out (size (config%prt)))
     do i = 1, size (config%prt)
        select type (prt_config => config%prt(i)%c)
        type is (stable_config_t)
           allocate (stable_t :: term%particle_out(i)%c)
           select type (stable => term%particle_out(i)%c)
           type is (stable_t)
              call stable%init (prt_config)
           end select
        type is (unstable_config_t)
           allocate (unstable_t :: term%particle_out(i)%c)
           select type (unstable => term%particle_out(i)%c)
           type is (unstable_t)
              call unstable%init (prt_config)
           end select
        end select
     end do
   end subroutine decay_term_init
 
 @ %def decay_term_init
 @ Implement a RNG instance, spawned by the process object.
 <<Decays: decay term: TBP>>=
   procedure :: make_rng => decay_term_make_rng
 <<Decays: procedures>>=
   subroutine decay_term_make_rng (term, process)
     class(decay_term_t), intent(inout) :: term
     type(process_t), intent(inout) :: process
     class(rng_t), allocatable :: rng
     integer :: i
     do i = 1, size (term%particle_out)
        select type (unstable => term%particle_out(i)%c)
        type is (unstable_t)
           call process%make_rng (rng)
           call unstable%import_rng (rng)
        end select
     end do
   end subroutine decay_term_make_rng
 
 @ %def decay_term_make_rng
 @ Link the interactions for unstable decay products to the
 interaction of the parent process.
 <<Decays: decay term: TBP>>=
   procedure :: link_interactions => decay_term_link_interactions
 <<Decays: procedures>>=
   recursive subroutine decay_term_link_interactions (term, trace)
     class(decay_term_t), intent(inout) :: term
     type(interaction_t), intent(in), target :: trace
     integer :: i
     do i = 1, size (term%particle_out)
        select type (unstable => term%particle_out(i)%c)
        type is (unstable_t)
           call unstable%link_interactions (i, trace)
        end select
     end do
   end subroutine decay_term_link_interactions
 
 @ %def decay_term_link_interactions
 @ Recursively generate a decay chain, for each of the unstable
 particles in the final state.
 <<Decays: decay term: TBP>>=
   procedure :: select_chain => decay_term_select_chain
 <<Decays: procedures>>=
   recursive subroutine decay_term_select_chain (term)
     class(decay_term_t), intent(inout) :: term
     integer :: i
     do i = 1, size (term%particle_out)
        select type (unstable => term%particle_out(i)%c)
        type is (unstable_t)
           call unstable%select_chain ()
        end select
     end do
   end subroutine decay_term_select_chain
 
 @ %def decay_term_select_chain
 @ Recursively generate a decay event, for each of the unstable
 particles in the final state.
 <<Decays: decay term: TBP>>=
   procedure :: generate => decay_term_generate
 <<Decays: procedures>>=
   recursive subroutine decay_term_generate (term)
     class(decay_term_t), intent(inout) :: term
     integer :: i
     do i = 1, size (term%particle_out)
        select type (unstable => term%particle_out(i)%c)
        type is (unstable_t)
           call unstable%generate ()
        end select
     end do
   end subroutine decay_term_generate
 
 @ %def decay_term_generate
 @
 \subsection{Decay Root Configuration}
 At the root of a decay chain, there is a parent process.  The decay root
 stores a pointer to the parent process and the set of decay configurations.
 <<Decays: public>>=
   public :: decay_root_config_t
 <<Decays: types>>=
   type :: decay_root_config_t
      private
      type(string_t) :: process_id
      type(process_t), pointer :: process => null ()
      class(model_data_t), pointer :: model => null ()
      type(decay_term_config_t), dimension(:), allocatable :: term_config
    contains
    <<Decays: decay root config: TBP>>
   end type decay_root_config_t
 
 @ %def decay_root_config_t
 @ The finalizer is recursive since there may be cascade decays.
 <<Decays: decay root config: TBP>>=
   procedure :: final => decay_root_config_final
 <<Decays: procedures>>=
   recursive subroutine decay_root_config_final (object)
     class(decay_root_config_t), intent(inout) :: object
     integer :: i
     if (allocated (object%term_config)) then
        do i = 1, size (object%term_config)
           call object%term_config(i)%final ()
        end do
     end if
   end subroutine decay_root_config_final
 
 @ %def decay_root_config_final
 @ The output routine is also recursive, and it contains an adjustable
 indentation.
 <<Decays: decay root config: TBP>>=
   procedure :: write => decay_root_config_write
   procedure :: write_header => decay_root_config_write_header
   procedure :: write_terms => decay_root_config_write_terms
 <<Decays: procedures>>=
   recursive subroutine decay_root_config_write (object, unit, indent, verbose)
     class(decay_root_config_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent
     logical, intent(in), optional :: verbose
     integer :: u, ind
     u = given_output_unit (unit)
     ind = 0;  if (present (indent))  ind = indent
     call write_indent (u, ind)
     write (u, "(1x,A)")  "Final-state decay tree:"
     call object%write_header (unit, indent)
     call object%write_terms (unit, indent, verbose)
   end subroutine decay_root_config_write
 
   subroutine decay_root_config_write_header (object, unit, indent)
     class(decay_root_config_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent
     integer :: u, ind
     u = given_output_unit (unit)
     ind = 0;  if (present (indent))  ind = indent
     call write_indent (u, ind)
     if (associated (object%process)) then
        write (u, 3)  "process ID      =", char (object%process_id), "*"
     else
        write (u, 3)  "process ID      =", char (object%process_id)
     end if
 3   format (3x,A,2(1x,A))
   end subroutine decay_root_config_write_header
 
   recursive subroutine decay_root_config_write_terms &
        (object, unit, indent, verbose)
     class(decay_root_config_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent
     logical, intent(in), optional :: verbose
     integer :: i, u, ind
     logical :: verb
     u = given_output_unit (unit)
     ind = 0;  if (present (indent))  ind = indent
     verb = .true.;  if (present (verbose))  verb = verbose
     if (verb .and. allocated (object%term_config)) then
        do i = 1, size (object%term_config)
           call object%term_config(i)%write (u, ind + 1)
        end do
     end if
   end subroutine decay_root_config_write_terms
 
 @ %def decay_root_config_write
 @ Initialize for a named process and (optionally) a pre-determined
 number of terms.
 <<Decays: decay root config: TBP>>=
   procedure :: init => decay_root_config_init
 <<Decays: procedures>>=
   subroutine decay_root_config_init (decay, model, process_id, n_terms)
     class(decay_root_config_t), intent(out) :: decay
     class(model_data_t), intent(in), target :: model
     type(string_t), intent(in) :: process_id
     integer, intent(in), optional :: n_terms
     decay%model => model
     decay%process_id = process_id
     if (present (n_terms)) then
        allocate (decay%term_config (n_terms))
     end if
   end subroutine decay_root_config_init
 
 @ %def decay_root_config_init
 @ Declare a decay term, given an array of flavors.
 <<Decays: decay root config: TBP>>=
   procedure :: init_term => decay_root_config_init_term
 <<Decays: procedures>>=
   recursive subroutine decay_root_config_init_term &
        (decay, i, flv, stable, model, process_stack, var_list)
     class(decay_root_config_t), intent(inout) :: decay
     integer, intent(in) :: i
     type(flavor_t), dimension(:,:), intent(in) :: flv
     logical, dimension(:), intent(in) :: stable
     class(model_data_t), intent(in), target :: model
     type(process_stack_t), intent(in), optional :: process_stack
     type(var_list_t), intent(in), optional, target :: var_list
     call decay%term_config(i)%init (flv, stable, model, process_stack, var_list)
   end subroutine decay_root_config_init_term
 
 @ %def decay_root_config_init_term
 @ Connect the decay root configuration with a process object (which should
 represent the parent process).  This includes initialization, therefore
 intent(out).
 
 The flavor state is retrieved from the process term object.  However, we have
 to be careful: the flavor object points to the model instance that is stored
 in the process object.  This model instance may not contain the current
 setting for unstable particles and decay.  Therefore, we assign the model
 directly.
 
 If the [[process_instance]] argument is provided, we use this for the
 flavor state.  This applies to the decay root only, where the process
 can be entangled with a beam setup, and the latter contains beam
 remnants as further outgoing particles.  These must be included in the
 set of outgoing flavors, since the decay application is also done on
 the connected state.
 
 Infer stability from the particle properties, using the first row in the set
 of flavor states.  For unstable particles, we look for decays,
 recursively, available from the process stack (if present).
 
 For the unstable particles, we have to check whether their masses
 match between the production and the decay.  Fortunately, both
 versions are available for comparison.
 
 The optional [[var_list]] argument may override integral/error
 values for decay processes.
 <<Decays: decay root config: TBP>>=
   procedure :: connect => decay_root_config_connect
 <<Decays: procedures>>=
   recursive subroutine decay_root_config_connect &
        (decay, process, model, process_stack, process_instance, var_list)
     class(decay_root_config_t), intent(out) :: decay
     type(process_t), intent(in), target :: process
     class(model_data_t), intent(in), target :: model
     type(process_stack_t), intent(in), optional :: process_stack
     type(process_instance_t), intent(in), optional, target :: process_instance
     type(var_list_t), intent(in), optional, target :: var_list
     type(connected_state_t), pointer :: connected_state
     type(interaction_t), pointer :: int
     type(flavor_t), dimension(:,:), allocatable :: flv
     logical, dimension(:), allocatable :: stable
     real(default), dimension(:), allocatable :: m_prod, m_dec
     integer :: i
     call decay%init (model, process%get_id (), process%get_n_terms ())
     do i = 1, size (decay%term_config)
        if (present (process_instance)) then
           connected_state => process_instance%get_connected_state_ptr (i)
           int => connected_state%get_matrix_int_ptr ()
           call interaction_get_flv_out (int, flv)
        else
           call process%get_term_flv_out (i, flv)
        end if
        allocate (m_prod (size (flv(:,1)%get_mass ())))
        m_prod = flv(:,1)%get_mass ()
        call flv%set_model (model)
        allocate (m_dec (size (flv(:,1)%get_mass ())))
        m_dec = flv(:,1)%get_mass ()
        allocate (stable (size (flv, 1)))
        stable = flv(:,1)%is_stable ()
        call check_masses ()
        call decay%init_term (i, flv, stable, model, process_stack, var_list)
        deallocate (flv, stable, m_prod, m_dec)
     end do
     decay%process => process
   contains
     subroutine check_masses ()
       integer :: i
       logical :: ok
       ok = .true.
       do i = 1, size (m_prod)
          if (.not. stable(i)) then
             if (.not. nearly_equal (m_prod(i), m_dec(i))) then
                write (msg_buffer, "(A,A,A)")  "particle '", &
                     char (flv(i,1)%get_name ()), "':"
                call msg_message
                write (msg_buffer, &
                     "(2x,A,1x," // FMT_15 // ",3x,A,1x," // FMT_15 // ")") &
                     "m_prod =", m_prod(i), "m_dec =", m_dec(i)
                call msg_message
                ok = .false.
             end if
          end if
       end do
       if (.not. ok)  call msg_fatal &
            ("Particle mass mismatch between production and decay")
     end subroutine check_masses
   end subroutine decay_root_config_connect
 
 @ %def decay_root_config_connect
 @ Recursively compute widths, errors, and branching ratios.
 <<Decays: decay root config: TBP>>=
   procedure :: compute => decay_root_config_compute
 <<Decays: procedures>>=
   recursive subroutine decay_root_config_compute (decay)
     class(decay_root_config_t), intent(inout) :: decay
     integer :: i
     do i = 1, size (decay%term_config)
        call decay%term_config(i)%compute ()
     end do
   end subroutine decay_root_config_compute
 
 @ %def decay_root_config_compute
 @
 \subsection{Decay Root Instance}
 This is the common parent type for decay and decay root.  The process instance
 points to the parent process.  The model pointer is separate because particle
 settings may be updated w.r.t.\ the parent process object.
 <<Decays: types>>=
   type, abstract :: decay_gen_t
      private
      type(decay_term_t), dimension(:), allocatable :: term
      type(process_instance_t), pointer :: process_instance => null ()
      integer :: selected_mci = 0
      integer :: selected_term = 0
    contains
    <<Decays: decay gen: TBP>>
   end type decay_gen_t
 
 @ %def decay_gen_t
 @
 The decay root represents the parent process.  When an event is generated, the
 generator selects the term to which the decay chain applies (if possible).
 
 The process instance is just a pointer.
 <<Decays: public>>=
   public :: decay_root_t
 <<Decays: types>>=
   type, extends (decay_gen_t) :: decay_root_t
      private
      type(decay_root_config_t), pointer :: config => null ()
    contains
    <<Decays: decay root: TBP>>
   end type decay_root_t
 
 @ %def decay_root_t
 @ The finalizer has to recursively finalize the terms, but we can skip the
 process instance which is not explicitly allocated.
 <<Decays: decay gen: TBP>>=
   procedure :: base_final => decay_gen_final
 <<Decays: procedures>>=
   recursive subroutine decay_gen_final (object)
     class(decay_gen_t), intent(inout) :: object
     integer :: i
     if (allocated (object%term)) then
        do i = 1, size (object%term)
           call object%term(i)%final ()
        end do
     end if
   end subroutine decay_gen_final
 
 @ %def decay_gen_final
 @ No extra finalization for the decay root.
 <<Decays: decay root: TBP>>=
   procedure :: final => decay_root_final
 <<Decays: procedures>>=
   subroutine decay_root_final (object)
     class(decay_root_t), intent(inout) :: object
     call object%base_final ()
   end subroutine decay_root_final
 
 @ %def decay_gen_final
 @ Output.
 <<Decays: decay root: TBP>>=
   procedure :: write => decay_root_write
 <<Decays: procedures>>=
   subroutine decay_root_write (object, unit)
     class(decay_root_t), intent(in) :: object
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     if (associated (object%config)) then
        call object%config%write (unit, verbose = .false.)
     else
        write (u, "(1x,A)")  "Final-state decay tree: [not configured]"
     end if
     if (object%selected_mci > 0) then
        write (u, "(3x,A,I0)")  "Selected MCI    = ", object%selected_mci
     else
        write (u, "(3x,A)")  "Selected MCI    = [undefined]"
     end if
     if (object%selected_term > 0) then
        write (u, "(3x,A,I0)")  "Selected term   = ", object%selected_term
        call object%term(object%selected_term)%write (u, 1)
     else
        write (u, "(3x,A)")  "Selected term   = [undefined]"
     end if
   end subroutine decay_root_write
 
 @ %def decay_root_write
 @ Write the process instances, recursively.
 <<Decays: decay gen: TBP>>=
   procedure :: write_process_instances => decay_gen_write_process_instances
 <<Decays: procedures>>=
   recursive subroutine decay_gen_write_process_instances (decay, unit, verbose)
     class(decay_gen_t), intent(in) :: decay
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose
     logical :: verb
     verb = .true.;  if (present (verbose))  verb = verbose
     if (associated (decay%process_instance)) then
        if (verb) then
           call decay%process_instance%write (unit)
        else
           call decay%process_instance%write_header (unit)
        end if
     end if
     if (decay%selected_term > 0) then
        call decay%term(decay%selected_term)%write_process_instances (unit, verb)
     end if
   end subroutine decay_gen_write_process_instances
 
 @ %def decay_gen_write_process_instances
 @ Generic initializer.  All can be done recursively.
 <<Decays: decay gen: TBP>>=
   procedure :: base_init => decay_gen_init
 <<Decays: procedures>>=
   recursive subroutine decay_gen_init (decay, term_config)
     class(decay_gen_t), intent(out) :: decay
     type(decay_term_config_t), dimension(:), intent(in), target :: term_config
     integer :: i
     allocate (decay%term (size (term_config)))
     do i = 1, size (decay%term)
        call decay%term(i)%init (term_config(i))
     end do
   end subroutine decay_gen_init
 
 @ %def decay_gen_init
 @ Specific initializer.  We assign the configuration object, which should
 correspond to a completely initialized decay configuration tree.  We
 also connect to an existing process instance.  Then, we recursively
 link the child interactions to the parent process.
 <<Decays: decay root: TBP>>=
   procedure :: init => decay_root_init
 <<Decays: procedures>>=
   subroutine decay_root_init (decay_root, config, process_instance)
     class(decay_root_t), intent(out) :: decay_root
     type(decay_root_config_t), intent(in), target :: config
     type(process_instance_t), intent(in), target :: process_instance
     call decay_root%base_init (config%term_config)
     decay_root%config => config
     decay_root%process_instance => process_instance
     call decay_root%make_term_rng (config%process)
     call decay_root%link_term_interactions ()
   end subroutine decay_root_init
 
 @ %def decay_root_init
 @ Explicitly set/get mci and term indices.  (Used in unit test.)
 <<Decays: decay gen: TBP>>=
   procedure :: set_mci => decay_gen_set_mci
   procedure :: set_term => decay_gen_set_term
   procedure :: get_mci => decay_gen_get_mci
   procedure :: get_term => decay_gen_get_term
 <<Decays: procedures>>=
   subroutine decay_gen_set_mci (decay, i)
     class(decay_gen_t), intent(inout) :: decay
     integer, intent(in) :: i
     decay%selected_mci = i
   end subroutine decay_gen_set_mci
 
   subroutine decay_gen_set_term (decay, i)
     class(decay_gen_t), intent(inout) :: decay
     integer, intent(in) :: i
     decay%selected_term = i
   end subroutine decay_gen_set_term
 
   function decay_gen_get_mci (decay) result (i)
     class(decay_gen_t), intent(inout) :: decay
     integer :: i
     i = decay%selected_mci
   end function decay_gen_get_mci
 
   function decay_gen_get_term (decay) result (i)
     class(decay_gen_t), intent(inout) :: decay
     integer :: i
     i = decay%selected_term
   end function decay_gen_get_term
 
 @ %def decay_gen_set_mci
 @ %def decay_gen_set_term
 @ %def decay_gen_get_mci
 @ %def decay_gen_get_term
 @ Implement random-number generators for unstable decay selection in
 all terms.  This is not recursive.
 
 We also make use of the fact that [[process]] is a pointer; the (state
 of the RNG factory inside the) target process will be modified by the
 rng-spawning method, but not the pointer.
 <<Decays: decay gen: TBP>>=
   procedure :: make_term_rng => decay_gen_make_term_rng
 <<Decays: procedures>>=
   subroutine decay_gen_make_term_rng (decay, process)
     class(decay_gen_t), intent(inout) :: decay
     type(process_t), intent(in), pointer :: process
     integer :: i
     do i = 1, size (decay%term)
        call decay%term(i)%make_rng (process)
     end do
   end subroutine decay_gen_make_term_rng
 
 @ %def decay_gen_make_term_rng
 @ Recursively link interactions of the enclosed decay terms to the
 corresponding terms in the current process instance.
 
 Note: A bug in nagfor requires the extra [[i_term]] variable.
 <<Decays: decay gen: TBP>>=
   procedure :: link_term_interactions => decay_gen_link_term_interactions
 <<Decays: procedures>>=
   recursive subroutine decay_gen_link_term_interactions (decay)
     class(decay_gen_t), intent(inout) :: decay
     integer :: i, i_term
     type(interaction_t), pointer :: trace
     associate (instance => decay%process_instance)
       do i = 1, size (decay%term)
          i_term = i
          trace => instance%get_trace_int_ptr (i_term)
          call decay%term(i_term)%link_interactions (trace)
       end do
     end associate
   end subroutine decay_gen_link_term_interactions
 
 @ %def decay_gen_link_term_interactions
 @ Select a decay chain: decay modes and process components.
 <<Decays: decay root: TBP>>=
   procedure :: select_chain => decay_root_select_chain
 <<Decays: procedures>>=
   subroutine decay_root_select_chain (decay_root)
     class(decay_root_t), intent(inout) :: decay_root
     if (decay_root%selected_term > 0) then
        call decay_root%term(decay_root%selected_term)%select_chain ()
     else
        call msg_bug ("Decays: no term selected for parent process")
     end if
   end subroutine decay_root_select_chain
 
 @ %def decay_root_select_chain
 @ Generate a decay tree, i.e., for the selected term in the parent
 process, recursively generate a decay event for all unstable
 particles.
 
 Factor out the trace of the connected state of the parent process.
 This trace should not be taken into account for unweighting the decay
 chain, since it was already used for unweighting the parent event, or
 it determines the overall event weight.
 <<Decays: decay root: TBP>>=
   procedure :: generate => decay_root_generate
 <<Decays: procedures>>=
   subroutine decay_root_generate (decay_root)
     class(decay_root_t), intent(inout) :: decay_root
     type(connected_state_t), pointer :: connected_state
     if (decay_root%selected_term > 0) then
        connected_state => decay_root%process_instance%get_connected_state_ptr &
             (decay_root%selected_term)
        call connected_state%normalize_matrix_by_trace ()
        call decay_root%term(decay_root%selected_term)%generate ()
     else
        call msg_bug ("Decays: no term selected for parent process")
     end if
   end subroutine decay_root_generate
 
 @ %def decay_root_generate
 @
 \subsection{Decay Configuration}
 A decay configuration describes a distinct decay mode of a particle.  Each
 decay mode may include several terms, which correspond to the terms in the
 associated process.  In addition to the base type, the decay configuration
 object contains the integral of the parent process and the selector for the
 MCI group inside this process.
 
 The flavor component should be identical to the flavor component of the parent
 particle ([[unstable]] object).
 <<Decays: types>>=
   type, extends (decay_root_config_t) :: decay_config_t
      private
      type(flavor_t) :: flv
      real(default) :: weight = 0
      real(default) :: integral = 0
      real(default) :: abs_error = 0
      real(default) :: rel_error = 0
      type(selector_t) :: mci_selector
    contains
    <<Decays: decay config: TBP>>
   end type decay_config_t
 
 @ %def decay_config_t
 @ The output routine extends the decay-root writer by listing numerical
 component values.
 <<Decays: decay config: TBP>>=
   procedure :: write => decay_config_write
 <<Decays: procedures>>=
   recursive subroutine decay_config_write (object, unit, indent, verbose)
     class(decay_config_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent
     logical, intent(in), optional :: verbose
     integer :: u, ind
     u = given_output_unit (unit)
     ind = 0;  if (present (indent))  ind = indent
     call write_indent (u, ind)
     write (u, "(1x,A)")  "Decay:"
     call object%write_header (unit, indent)
     call write_indent (u, ind)
     write (u, 2)  "branching ratio =", object%weight * 100
     call write_indent (u, ind)
     write (u, 1)  "partial width   =", object%integral
     call write_indent (u, ind)
     write (u, 1)  "error (abs)     =", object%abs_error
     call write_indent (u, ind)
     write (u, 1)  "error (rel)     =", object%rel_error
 1   format (3x,A,ES19.12)
 2   format (3x,A,F11.6,1x,'%')
     call object%write_terms (unit, indent, verbose)
   end subroutine decay_config_write
 
 @ %def decay_config_write
 @ Connect a decay configuration with a process object (which should
 represent the decay).  This includes initialization, therefore
 intent(out).  We first connect the process itself, then do initializations
 that are specific for this decay.
 
 Infer stability from the particle properties, using the first row in the set
 of flavor states.  Once we can deal with predetermined decay chains, they
 should be used instead.
 
 If there is an optional [[var_list]], check if the stored values for
 the decay partial width and error have been overridden there.
 <<Decays: decay config: TBP>>=
   procedure :: connect => decay_config_connect
 <<Decays: procedures>>=
   recursive subroutine decay_config_connect &
        (decay, process, model, process_stack, process_instance, var_list)
     class(decay_config_t), intent(out) :: decay
     type(process_t), intent(in), target :: process
     class(model_data_t), intent(in), target :: model
     type(process_stack_t), intent(in), optional :: process_stack
     type(process_instance_t), intent(in), optional, target :: process_instance
     type(var_list_t), intent(in), optional, target :: var_list
     real(default), dimension(:), allocatable :: integral_mci
     type(string_t) :: process_id
     integer :: i, n_mci
     call decay%decay_root_config_t%connect &
          (process, model, process_stack, var_list=var_list)
     process_id = process%get_id ()
     if (process%cm_frame ()) then
        call msg_fatal ("Decay process " // char (process_id) &
             // ": unusable because rest frame is fixed.")
     end if
     decay%integral = process%get_integral ()
     decay%abs_error = process%get_error ()
     if (present (var_list)) then
        call update (decay%integral, "integral(" // process_id // ")")
        call update (decay%abs_error, "error(" // process_id // ")")
     end if
     n_mci = process%get_n_mci ()
     allocate (integral_mci (n_mci))
     do i = 1, n_mci
        integral_mci(i) = process%get_integral_mci (i)
     end do
     call decay%mci_selector%init (integral_mci)
   contains
     subroutine update (var, var_name)
       real(default), intent(inout) :: var
       type(string_t), intent(in) :: var_name
       if (var_list%contains (var_name)) then
          var = var_list%get_rval (var_name)
       end if
     end subroutine update
   end subroutine decay_config_connect
 
 @ %def decay_config_connect
 @ Set the flavor entry, which repeats the flavor of the parent unstable
 particle.
 <<Decays: decay config: TBP>>=
   procedure :: set_flv => decay_config_set_flv
 <<Decays: procedures>>=
   subroutine decay_config_set_flv (decay, flv)
     class(decay_config_t), intent(inout) :: decay
     type(flavor_t), intent(in) :: flv
     decay%flv = flv
   end subroutine decay_config_set_flv
 
 @ %def decay_config_set_flv
 @ Compute embedded branchings and the relative error.  This method does not
 apply to the decay root.
 <<Decays: decay config: TBP>>=
   procedure :: compute => decay_config_compute
 <<Decays: procedures>>=
   recursive subroutine decay_config_compute (decay)
     class(decay_config_t), intent(inout) :: decay
     call decay%decay_root_config_t%compute ()
     if (.not. vanishes (decay%integral)) then
        decay%rel_error = decay%abs_error / decay%integral
     else
        decay%rel_error = 0
     end if
   end subroutine decay_config_compute
 
 @ %def decay_config_compute
 @
 \subsection{Decay Instance}
 The decay contains a collection of terms.  One of them is selected when the
 decay is evaluated.  This is similar to the decay root, but we implement it
 independently.
 
 The process instance object is allocated via a pointer, so it automatically
 behaves as a target.
 <<Decays: types>>=
   type, extends (decay_gen_t) :: decay_t
      private
      type(decay_config_t), pointer :: config => null ()
      class(rng_t), allocatable :: rng
    contains
    <<Decays: decay: TBP>>
   end type decay_t
 
 @ %def decay_t
 @ The finalizer is recursive.
 <<Decays: decay: TBP>>=
   procedure :: final => decay_final
 <<Decays: procedures>>=
   recursive subroutine decay_final (object)
     class(decay_t), intent(inout) :: object
     integer :: i
     call object%base_final ()
     do i = 1, object%config%process%get_n_mci ()
        call object%process_instance%final_simulation (i)
     end do
     call object%process_instance%final ()
     deallocate (object%process_instance)
   end subroutine decay_final
 
 @ %def decay_final
 @ Output.
 <<Decays: decay: TBP>>=
   procedure :: write => decay_write
 <<Decays: procedures>>=
   recursive subroutine decay_write (object, unit, indent, recursive)
     class(decay_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent, recursive
     integer :: u, ind
     u = given_output_unit (unit)
     ind = 0;  if (present (indent))  ind = indent
     call object%config%write (unit, indent, verbose = .false.)
     if (allocated (object%rng)) then
        call object%rng%write (u, ind + 1)
     end if
     call write_indent (u, ind)
     if (object%selected_mci > 0) then
        write (u, "(3x,A,I0)")  "Selected MCI    = ", object%selected_mci
     else
        write (u, "(3x,A)")  "Selected MCI    = [undefined]"
     end if
     call write_indent (u, ind)
     if (object%selected_term > 0) then
        write (u, "(3x,A,I0)")  "Selected term   = ", object%selected_term
        call object%term(object%selected_term)%write (u, ind + 1)
     else
        write (u, "(3x,A)")  "Selected term   = [undefined]"
     end if
   end subroutine decay_write
 
 @ %def decay_write
 @ Initializer.  Base initialization is done recursively.  Then, we
 prepare the current process instance and allocate a random-number
 generator for term selection.  For all unstable particles, we also
 allocate a r.n.g. as spawned by the current process.
 <<Decays: decay: TBP>>=
   procedure :: init => decay_init
 <<Decays: procedures>>=
   recursive subroutine decay_init (decay, config)
     class(decay_t), intent(out) :: decay
     type(decay_config_t), intent(in), target :: config
     integer :: i
     call decay%base_init (config%term_config)
     decay%config => config
     allocate (decay%process_instance)
     call decay%process_instance%init (decay%config%process)
     call decay%process_instance%setup_event_data (decay%config%model)
     do i = 1, decay%config%process%get_n_mci ()
        call decay%process_instance%init_simulation (i)
     end do
     call decay%config%process%make_rng (decay%rng)
     call decay%make_term_rng (decay%config%process)
   end subroutine decay_init
 
 @ %def decay_init
 @ Link interactions to the parent process.  [[i_prt]] is the index of
 the current outgoing particle in the parent interaction, for which we
 take the trace evaluator.  We link it to the beam particle in the beam
 interaction of the decay process instance.  Then, repeat the procedure
 for the outgoing particles.
 <<Decays: decay: TBP>>=
   procedure :: link_interactions => decay_link_interactions
 <<Decays: procedures>>=
   recursive subroutine decay_link_interactions (decay, i_prt, trace)
     class(decay_t), intent(inout) :: decay
     integer, intent(in) :: i_prt
     type(interaction_t), intent(in), target :: trace
     type(interaction_t), pointer :: beam_int
     integer :: n_in, n_vir
     beam_int => decay%process_instance%get_beam_int_ptr ()
     n_in = trace%get_n_in ()
     n_vir = trace%get_n_vir ()
     call beam_int%set_source_link (1, trace, &
          n_in + n_vir + i_prt)
     call decay%link_term_interactions ()
   end subroutine decay_link_interactions
 
 @ %def decay_link_interactions
 @ Determine a decay chain.  For each unstable particle we select one
 of the possible decay modes, and for each decay process we select one
 of the possible decay MCI components, calling the random-number
 generators.  We do not generate momenta, yet.
 <<Decays: decay: TBP>>=
   procedure :: select_chain => decay_select_chain
 <<Decays: procedures>>=
   recursive subroutine decay_select_chain (decay)
     class(decay_t), intent(inout) :: decay
     real(default) :: x
     integer :: i
     call decay%rng%generate (x)
     decay%selected_mci = decay%config%mci_selector%select (x)
     call decay%process_instance%choose_mci (decay%selected_mci)
     decay%selected_term = decay%process_instance%select_i_term ()
     do i = 1, size (decay%term)
        call decay%term(i)%select_chain ()
     end do
   end subroutine decay_select_chain
 
 @ %def decay_select_chain
 @ Generate a decay.  We first receive the beam momenta from the parent
 process (assuming that this is properly linked), then call the
 associated process object for a new event.
 
 Factor out the trace of the helicity density matrix of the isolated
 state (the one that will be used for the decay chain).  The trace is
 taken into account for unweighting the individual decay event and
 should therefore be ignored for unweighting the correlated decay
 chain afterwards.
 <<Decays: decay: TBP>>=
   procedure :: generate => decay_generate
 <<Decays: procedures>>=
   recursive subroutine decay_generate (decay)
     class(decay_t), intent(inout) :: decay
     type(isolated_state_t), pointer :: isolated_state
     integer :: i
     call decay%process_instance%receive_beam_momenta ()
     call decay%process_instance%generate_unweighted_event (decay%selected_mci)
     if (signal_is_pending ())  return
     call decay%process_instance%evaluate_event_data ()
     isolated_state => &
          decay%process_instance%get_isolated_state_ptr (decay%selected_term)
     call isolated_state%normalize_matrix_by_trace ()
     do i = 1, size (decay%term)
        call decay%term(i)%generate ()
        if (signal_is_pending ())  return
     end do
   end subroutine decay_generate
 
 @ %def decay_generate
 @
 \subsection{Stable Particles}
 This is a stable particle.  The flavor can be ambiguous (e.g., partons).
 <<Decays: types>>=
   type, extends (any_config_t) :: stable_config_t
      private
      type(flavor_t), dimension(:), allocatable :: flv
    contains
    <<Decays: stable config: TBP>>
   end type stable_config_t
 
 @ %def stable_config_t
 @ The finalizer is empty:
 <<Decays: stable config: TBP>>=
   procedure :: final => stable_config_final
 <<Decays: procedures>>=
   subroutine stable_config_final (object)
     class(stable_config_t), intent(inout) :: object
   end subroutine stable_config_final
 
 @ %def stable_config_final
 @ Output.
 <<Decays: stable config: TBP>>=
   procedure :: write => stable_config_write
 <<Decays: procedures>>=
   recursive subroutine stable_config_write (object, unit, indent, verbose)
     class(stable_config_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent
     logical, intent(in), optional :: verbose
     integer :: u, i, ind
     u = given_output_unit (unit)
     ind = 0;  if (present (indent))  ind = indent
     call write_indent (u, ind)
     write (u, "(1x,'+',1x,A)", advance = "no")  "Stable:"
     write (u, "(1x,A)", advance = "no")  char (object%flv(1)%get_name ())
     do i = 2, size (object%flv)
        write (u, "(':',A)", advance = "no") &
             char (object%flv(i)%get_name ())
     end do
     write (u, *)
   end subroutine stable_config_write
 
 @ %def stable_config_write
 @ Initializer.  We are presented with an array of flavors, but there may be
 double entries which we remove, so we store only the distinct flavors.
 <<Decays: stable config: TBP>>=
   procedure :: init => stable_config_init
 <<Decays: procedures>>=
   subroutine stable_config_init (config, flv)
     class(stable_config_t), intent(out) :: config
     type(flavor_t), dimension(:), intent(in) :: flv
     integer, dimension (size (flv)) :: pdg
     logical, dimension (size (flv)) :: mask
     integer :: i
     pdg = flv%get_pdg ()
     mask(1) = .true.
     forall (i = 2 : size (pdg))
        mask(i) = all (pdg(i) /= pdg(1:i-1))
     end forall
     allocate (config%flv (count (mask)))
     config%flv = pack (flv, mask)
   end subroutine stable_config_init
 
 @ %def stable_config_init
 @ Here is the corresponding object instance.  Except for the pointer
 to the configuration, there is no content.
 <<Decays: types>>=
   type, extends (any_t) :: stable_t
      private
      type(stable_config_t), pointer :: config => null ()
    contains
    <<Decays: stable: TBP>>
   end type stable_t
 
 @ %def stable_t
 @ The finalizer does nothing.
 <<Decays: stable: TBP>>=
   procedure :: final => stable_final
 <<Decays: procedures>>=
   subroutine stable_final (object)
     class(stable_t), intent(inout) :: object
   end subroutine stable_final
 
 @ %def stable_final
 @ We can delegate output to the configuration object.
 <<Decays: stable: TBP>>=
   procedure :: write => stable_write
 <<Decays: procedures>>=
   subroutine stable_write (object, unit, indent)
     class(stable_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent
     call object%config%write (unit, indent)
   end subroutine stable_write
 
 @ %def stable_write
 @ Initializer: just assign the configuration.
 <<Decays: stable: TBP>>=
   procedure :: init => stable_init
 <<Decays: procedures>>=
   subroutine stable_init (stable, config)
     class(stable_t), intent(out) :: stable
     type(stable_config_t), intent(in), target :: config
     stable%config => config
   end subroutine stable_init
 
 @ %def stable_init
 @
 \subsection{Unstable Particles}
 A branching configuration enables us to select among distinct decay
 modes of a particle.  We store the particle flavor (with its implicit
 link to a model), an array of decay configurations, and a selector object.
 
 The total width, absolute and relative error are stored as
 [[integral]], [[abs_error]], and [[rel_error]], respectively.
 
 The flavor must be unique in this case.
 <<Decays: public>>=
   public :: unstable_config_t
 <<Decays: types>>=
   type, extends (any_config_t) :: unstable_config_t
      private
      type(flavor_t) :: flv
      real(default) :: integral = 0
      real(default) :: abs_error = 0
      real(default) :: rel_error = 0
      type(selector_t) :: selector
      type(decay_config_t), dimension(:), allocatable :: decay_config
    contains
    <<Decays: unstable config: TBP>>
   end type unstable_config_t
 
 @ %def unstable_config_t
 @ Finalizer.  The branching configuration can be a recursive structure.
 <<Decays: unstable config: TBP>>=
   procedure :: final => unstable_config_final
 <<Decays: procedures>>=
   recursive subroutine unstable_config_final (object)
     class(unstable_config_t), intent(inout) :: object
     integer :: i
     if (allocated (object%decay_config)) then
        do i = 1, size (object%decay_config)
           call object%decay_config(i)%final ()
        end do
     end if
   end subroutine unstable_config_final
 
 @ %def unstable_config_final
 @ Output.  Since this may be recursive, we include indentation.
 <<Decays: unstable config: TBP>>=
   procedure :: write => unstable_config_write
 <<Decays: procedures>>=
   recursive subroutine unstable_config_write (object, unit, indent, verbose)
     class(unstable_config_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent
     logical, intent(in), optional :: verbose
     integer :: u, i, ind
     logical :: verb
     u = given_output_unit (unit)
     ind = 0;  if (present (indent))  ind = indent
     verb = .true.;  if (present (verbose))  verb = verbose
     call write_indent (u, ind)
     write (u, "(1x,'+',1x,A,1x,A)")  "Unstable:", &
          char (object%flv%get_name ())
     call write_indent (u, ind)
     write (u, 1)  "total width =", object%integral
     call write_indent (u, ind)
     write (u, 1)  "error (abs) =", object%abs_error
     call write_indent (u, ind)
     write (u, 1)  "error (rel) =", object%rel_error
 1   format (5x,A,ES19.12)
     if (verb .and. allocated (object%decay_config)) then
        do i = 1, size (object%decay_config)
           call object%decay_config(i)%write (u, ind + 1)
        end do
     end if
   end subroutine unstable_config_write
 
 @ %def unstable_config_write
 @ Initializer.  For the unstable particle, the flavor is unique.
 <<Decays: unstable config: TBP>>=
   procedure :: init => unstable_config_init
 <<Decays: procedures>>=
   subroutine unstable_config_init (unstable, flv, set_decays, model)
     class(unstable_config_t), intent(out) :: unstable
     type(flavor_t), intent(in) :: flv
     logical, intent(in), optional :: set_decays
     class(model_data_t), intent(in), optional, target :: model
     type(string_t), dimension(:), allocatable :: decay
     unstable%flv = flv
     if (present (set_decays)) then
        call unstable%flv%get_decays (decay)
        call unstable%init_decays (decay, model)
     end if
   end subroutine unstable_config_init
 
 @ %def unstable_config_init
 @ Further initialization: determine the number of decay modes.  We can assume
 that the flavor of the particle has been set already.
 
 If the process stack is given, we can delve recursively into actually
 assigning decay processes.  Otherwise, we just initialize with decay
 process names.
 <<Decays: unstable config: TBP>>=
   procedure :: init_decays => unstable_config_init_decays
 <<Decays: procedures>>=
   recursive subroutine unstable_config_init_decays &
        (unstable, decay_id, model, process_stack, var_list)
     class(unstable_config_t), intent(inout) :: unstable
     type(string_t), dimension(:), intent(in) :: decay_id
     class(model_data_t), intent(in), target :: model
     type(process_stack_t), intent(in), optional :: process_stack
     type(var_list_t), intent(in), optional :: var_list
     integer :: i
     allocate (unstable%decay_config (size (decay_id)))
     do i = 1, size (decay_id)
        associate (decay => unstable%decay_config(i))
          if (present (process_stack)) then
             call decay%connect (process_stack%get_process_ptr (decay_id(i)), &
                  model, process_stack, var_list=var_list)
          else
             call decay%init (model, decay_id(i))
          end if
          call decay%set_flv (unstable%flv)
        end associate
     end do
   end subroutine unstable_config_init_decays
 
 @ %def unstable_config_init
 @ Explicitly connect a specific decay with a process.  This is used only in
 unit tests.
 <<Decays: unstable config: TBP>>=
   procedure :: connect_decay => unstable_config_connect_decay
 <<Decays: procedures>>=
   subroutine unstable_config_connect_decay (unstable, i, process, model)
     class(unstable_config_t), intent(inout) :: unstable
     integer, intent(in) :: i
     type(process_t), intent(in), target :: process
     class(model_data_t), intent(in), target :: model
     associate (decay => unstable%decay_config(i))
       call decay%connect (process, model)
     end associate
   end subroutine unstable_config_connect_decay
 
 @ %def unstable_config_connect_decay
 @ Compute the total width and branching ratios, initializing the decay
 selector.
 <<Decays: unstable config: TBP>>=
   procedure :: compute => unstable_config_compute
 <<Decays: procedures>>=
   recursive subroutine unstable_config_compute (unstable)
     class(unstable_config_t), intent(inout) :: unstable
     integer :: i
     do i = 1, size (unstable%decay_config)
        call unstable%decay_config(i)%compute ()
     end do
     unstable%integral = sum (unstable%decay_config%integral)
     if (unstable%integral <= 0) then
        call unstable%write ()
        call msg_fatal ("Decay configuration: computed total width is zero")
     end if
     unstable%abs_error = sqrt (sum (unstable%decay_config%abs_error ** 2))
     unstable%rel_error = unstable%abs_error / unstable%integral
     call unstable%selector%init (unstable%decay_config%integral)
     do i = 1, size (unstable%decay_config)
        unstable%decay_config(i)%weight &
             = unstable%selector%get_weight (i)
     end do
   end subroutine unstable_config_compute
 
 @ %def unstable_config_compute
 @
 Now we define the instance of an unstable particle.
 <<Decays: public>>=
   public :: unstable_t
 <<Decays: types>>=
   type, extends (any_t) :: unstable_t
      private
      type(unstable_config_t), pointer :: config => null ()
      class(rng_t), allocatable :: rng
      integer :: selected_decay = 0
      type(decay_t), dimension(:), allocatable :: decay
    contains
    <<Decays: unstable: TBP>>
   end type unstable_t
 
 @ %def unstable_t
 @ Recursive finalizer.
 <<Decays: unstable: TBP>>=
   procedure :: final => unstable_final
 <<Decays: procedures>>=
   recursive subroutine unstable_final (object)
     class(unstable_t), intent(inout) :: object
     integer :: i
     if (allocated (object%decay)) then
        do i = 1, size (object%decay)
           call object%decay(i)%final ()
        end do
     end if
   end subroutine unstable_final
 
 @ %def unstable_final
 @ Output.
 <<Decays: unstable: TBP>>=
   procedure :: write => unstable_write
 <<Decays: procedures>>=
   recursive subroutine unstable_write (object, unit, indent)
     class(unstable_t), intent(in) :: object
     integer, intent(in), optional :: unit, indent
     integer :: u, ind
     u = given_output_unit (unit)
     ind = 0;  if (present (indent))  ind = indent
     call object%config%write (u, ind, verbose=.false.)
     if (allocated (object%rng)) then
        call object%rng%write (u, ind + 2)
     end if
     call write_indent (u, ind)
     if (object%selected_decay > 0) then
        write (u, "(5x,A,I0)") "Sel. decay  = ", object%selected_decay
        call object%decay(object%selected_decay)%write (u, ind + 1)
     else
        write (u, "(5x,A)")  "Sel. decay  = [undefined]"
     end if
   end subroutine unstable_write
 
 @ %def unstable_write
 @ Write the embedded process instances.
 <<Decays: unstable: TBP>>=
   procedure :: write_process_instances => unstable_write_process_instances
 <<Decays: procedures>>=
   recursive subroutine unstable_write_process_instances &
        (unstable, unit, verbose)
     class(unstable_t), intent(in) :: unstable
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose
     if (unstable%selected_decay > 0) then
        call unstable%decay(unstable%selected_decay)% &
             write_process_instances (unit, verbose)
     end if
   end subroutine unstable_write_process_instances
 
 @ %def unstable_write_process_instances
 @ Initialization, using the configuration object.
 <<Decays: unstable: TBP>>=
   procedure :: init => unstable_init
 <<Decays: procedures>>=
   recursive subroutine unstable_init (unstable, config)
     class(unstable_t), intent(out) :: unstable
     type(unstable_config_t), intent(in), target :: config
     integer :: i
     unstable%config => config
     allocate (unstable%decay (size (config%decay_config)))
     do i = 1, size (config%decay_config)
        call unstable%decay(i)%init (config%decay_config(i))
     end do
   end subroutine unstable_init
 
 @ %def unstable_init
 @ Recursively link interactions to the parent process.  [[i_prt]] is
 the index of the current outgoing particle in the parent interaction.
 <<Decays: unstable: TBP>>=
   procedure :: link_interactions => unstable_link_interactions
 <<Decays: procedures>>=
   recursive subroutine unstable_link_interactions (unstable, i_prt, trace)
     class(unstable_t), intent(inout) :: unstable
     integer, intent(in) :: i_prt
     type(interaction_t), intent(in), target :: trace
     integer :: i
     do i = 1, size (unstable%decay)
        call unstable%decay(i)%link_interactions (i_prt, trace)
     end do
   end subroutine unstable_link_interactions
 
 @ %def unstable_link_interactions
 @ Import the random-number generator state.
 <<Decays: unstable: TBP>>=
   procedure :: import_rng => unstable_import_rng
 <<Decays: procedures>>=
   subroutine unstable_import_rng (unstable, rng)
     class(unstable_t), intent(inout) :: unstable
     class(rng_t), intent(inout), allocatable :: rng
     call move_alloc (from = rng, to = unstable%rng)
   end subroutine unstable_import_rng
 
 @ %def unstable_import_rng
 @ Generate a decay chain.  First select a decay mode, then call the
 [[select_chain]] method of the selected mode.
 <<Decays: unstable: TBP>>=
   procedure :: select_chain => unstable_select_chain
 <<Decays: procedures>>=
   recursive subroutine unstable_select_chain (unstable)
     class(unstable_t), intent(inout) :: unstable
     real(default) :: x
     call unstable%rng%generate (x)
     unstable%selected_decay = unstable%config%selector%select (x)
     call unstable%decay(unstable%selected_decay)%select_chain ()
   end subroutine unstable_select_chain
 
 @ %def unstable_select_chain
 @ Generate a decay event.
 <<Decays: unstable: TBP>>=
   procedure :: generate => unstable_generate
 <<Decays: procedures>>=
   recursive subroutine unstable_generate (unstable)
     class(unstable_t), intent(inout) :: unstable
     call unstable%decay(unstable%selected_decay)%generate ()
   end subroutine unstable_generate
 
 @ %def unstable_generate
 @
 \subsection{Decay Chain}
 While the decay configuration tree and the decay tree are static
 entities (during a simulation run), the decay chain is dynamically
 generated for each event.  The reason is that with the possibility of
 several decay modes for each particle, and several terms for each
 process, the total number of distinct decay chains is not under control.
 
 Each entry in the decay chain is a connected parton state.  The origin
 of the chain is a connected state in the parent process (not part of
 the chain itself).  For each decay, mode and term chosen, we convolute
 this with the isolated (!) state of the current decay, to generate a
 new connected state.  We accumulate this chain by recursively
 traversing the allocated decay tree.  Whenever a particle decays, it
 becomes virtual and is replaced by its decay product, while all other
 particles stay in the parton state as spectators.
 
 Technically, we implement the decay chain as a stack structure and
 include information from the associated decay object for easier
 debugging.  This is a decay chain entry:
 <<Decays: types>>=
   type, extends (connected_state_t) :: decay_chain_entry_t
      private
      integer :: index = 0
      type(decay_config_t), pointer :: config => null ()
      integer :: selected_mci = 0
      integer :: selected_term = 0
      type(decay_chain_entry_t), pointer :: previous => null ()
   end type decay_chain_entry_t
 
 @ %def decay_chain_entry_t
 @ This is the complete chain; we need just a pointer to the last
 entry.  We also include a pointer to the master process instance,
 which serves as the seed for the decay chain.
 
 The evaluator [[correlated_trace]] traces over all quantum numbers
 for the final spin-correlated (but color-summed) evaluator of the
 decay chain.  This allows us to compute the probability for a momentum
 configuration, given that all individual density matrices (of the
 initial process and the subsequent decays) have been normalized to one.
 
 Note: This trace is summed over color, so color is treated exactly
 when computing spin correlations.  However, we do not keep
 non-diagonal color correlations.  When an event is accepted, we
 compute probabilities for all color states and can choose one of them.
 <<Decays: public>>=
   public :: decay_chain_t
 <<Decays: types>>=
   type :: decay_chain_t
      private
      type(process_instance_t), pointer :: process_instance => null ()
      integer :: selected_term = 0
      type(evaluator_t) :: correlated_trace
      type(decay_chain_entry_t), pointer :: last => null ()
    contains
    <<Decays: decay chain: TBP>>
   end type decay_chain_t
 
 @ %def decay_chain_t
 @ The finalizer recursively deletes and deallocates the entries.
 <<Decays: decay chain: TBP>>=
   procedure :: final => decay_chain_final
 <<Decays: procedures>>=
   subroutine decay_chain_final (object)
     class(decay_chain_t), intent(inout) :: object
     type(decay_chain_entry_t), pointer :: entry
     do while (associated (object%last))
        entry => object%last
        object%last => entry%previous
        call entry%final ()
        deallocate (entry)
     end do
     call object%correlated_trace%final ()
   end subroutine decay_chain_final
 
 @ %def decay_chain_final
 @ Doing output recursively allows us to display the chain in
 chronological order.
 <<Decays: decay chain: TBP>>=
   procedure :: write => decay_chain_write
 <<Decays: procedures>>=
   subroutine decay_chain_write (object, unit)
     class(decay_chain_t), intent(in) :: object
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     call write_separator (u, 2)
     write (u, "(1x,A)")  "Decay chain:"
     call write_entries (object%last)
     call write_separator (u, 2)
     write (u, "(1x,A)")  "Evaluator (correlated trace of the decay chain):"
     call write_separator (u)
     call object%correlated_trace%write (u)
     call write_separator (u, 2)
   contains
     recursive subroutine write_entries (entry)
       type(decay_chain_entry_t), intent(in), pointer :: entry
       if (associated (entry)) then
          call write_entries (entry%previous)
          call write_separator (u, 2)
          write (u, "(1x,A,I0)")  "Decay #", entry%index
          call entry%config%write_header (u)
          write (u, "(3x,A,I0)")  "Selected MCI    = ", entry%selected_mci
          write (u, "(3x,A,I0)")  "Selected term   = ", entry%selected_term
          call entry%config%term_config(entry%selected_term)%write (u, indent=1)
          call entry%write (u)
       end if
     end subroutine write_entries
   end subroutine decay_chain_write
 
 @ %def decay_chain_write
 @
 Build a decay chain, recursively following the selected decays and
 terms in a decay tree.  Before start, we finalize the chain, deleting
 any previous contents.
 <<Decays: decay chain: TBP>>=
   procedure :: build => decay_chain_build
 <<Decays: procedures>>=
   subroutine decay_chain_build (chain, decay_root)
     class(decay_chain_t), intent(inout), target :: chain
     type(decay_root_t), intent(in) :: decay_root
     type(quantum_numbers_mask_t), dimension(:), allocatable :: qn_mask
     type(interaction_t), pointer :: int_last_decay
     call chain%final ()
     if (decay_root%selected_term > 0) then
        chain%process_instance => decay_root%process_instance
        chain%selected_term = decay_root%selected_term
        call chain%build_term_entries (decay_root%term(decay_root%selected_term))
     end if
     int_last_decay => chain%last%get_matrix_int_ptr ()
     allocate (qn_mask (int_last_decay%get_n_tot ()))
     call qn_mask%init (mask_f = .true., mask_c = .true., mask_h = .true.)
     call chain%correlated_trace%init_qn_sum (int_last_decay, qn_mask)
   end subroutine decay_chain_build
 
 @ %def decay_chain_build
 @ Build the entries that correspond to a decay term.  We have to scan
 all unstable particles.
 <<Decays: decay chain: TBP>>=
   procedure :: build_term_entries => decay_chain_build_term_entries
 <<Decays: procedures>>=
   recursive subroutine decay_chain_build_term_entries (chain, term)
     class(decay_chain_t), intent(inout) :: chain
     type(decay_term_t), intent(in) :: term
     integer :: i
     do i = 1, size (term%particle_out)
        select type (unstable => term%particle_out(i)%c)
        type is (unstable_t)
           if (unstable%selected_decay > 0) then
              call chain%build_decay_entries &
                   (unstable%decay(unstable%selected_decay))
           end if
        end select
     end do
   end subroutine decay_chain_build_term_entries
 
 @ %def decay_chain_build_term_entries
 @ Build the entries that correspond to a specific decay.  The
 decay term should have been determined, so we allocate a decay chain
 entry and fill it, then proceed to child decays.
 
 For the first entry, we convolute the connected state of the parent process
 instance with the isolated state of the current
 decay (which does not contain an extra beam entry for the parent).
 For subsequent entries, we take the previous entry as first factor.
 
 In principle, each chain entry (as a parton state) is capable of
 holding a subevent object and associated expressions.  We currently do
 not make use of that feature.
 
 Before generating the decays, factor out the trace of the helicity
 density matrix of the parent parton state.  This trace has
 been used for unweighting the original event (unweighted case) or it
 determines the overall weight, so it should not be taken into account
 in the decay chain generation.
 <<Decays: decay chain: TBP>>=
   procedure :: build_decay_entries => decay_chain_build_decay_entries
 <<Decays: procedures>>=
   recursive subroutine decay_chain_build_decay_entries (chain, decay)
     class(decay_chain_t), intent(inout) :: chain
     type(decay_t), intent(in) :: decay
     type(decay_chain_entry_t), pointer :: entry
     type(connected_state_t), pointer :: previous_state
     type(isolated_state_t), pointer :: current_decay
     type(helicity_t) :: hel
     type(quantum_numbers_t) :: qn_filter_conn
     allocate (entry)
     if (associated (chain%last)) then
        entry%previous => chain%last
        entry%index = entry%previous%index + 1
        previous_state => entry%previous%connected_state_t
     else
        entry%index = 1
        previous_state => &
             chain%process_instance%get_connected_state_ptr (chain%selected_term)
     end if
     entry%config => decay%config
     entry%selected_mci = decay%selected_mci
     entry%selected_term = decay%selected_term
     current_decay => decay%process_instance%get_isolated_state_ptr &
          (decay%selected_term)
     call entry%setup_connected_trace &
          (current_decay, previous_state%get_trace_int_ptr (), resonant=.true.)
     if (entry%config%flv%has_decay_helicity ()) then
        call hel%init (entry%config%flv%get_decay_helicity ())
        call qn_filter_conn%init (hel)
        call entry%setup_connected_matrix &
             (current_decay, previous_state%get_matrix_int_ptr (), &
             resonant=.true., qn_filter_conn = qn_filter_conn)
        call entry%setup_connected_flows &
             (current_decay, previous_state%get_flows_int_ptr (), &
             resonant=.true., qn_filter_conn = qn_filter_conn)
     else
        call entry%setup_connected_matrix &
             (current_decay, previous_state%get_matrix_int_ptr (), &
             resonant=.true.)
        call entry%setup_connected_flows &
             (current_decay, previous_state%get_flows_int_ptr (), &
             resonant=.true.)
     end if
     chain%last => entry
     call chain%build_term_entries (decay%term(decay%selected_term))
   end subroutine decay_chain_build_decay_entries
 
 @ %def decay_chain_build_decay_entries
 @ Recursively fill the decay chain with momenta and evaluate the
 matrix elements.  Since all evaluators should have correct source
 entries at this point, momenta are automatically retrieved from the
 appropriate process instance.
 
 
 Like we did above for the parent process, factor out the trace for
 each subsequent decay (the helicity density matrix in the isolated
 state, which is taken for the convolution).
 <<Decays: decay chain: TBP>>=
   procedure :: evaluate => decay_chain_evaluate
 <<Decays: procedures>>=
   subroutine decay_chain_evaluate (chain)
     class(decay_chain_t), intent(inout) :: chain
     call evaluate (chain%last)
     call chain%correlated_trace%receive_momenta ()
     call chain%correlated_trace%evaluate ()
   contains
     recursive subroutine evaluate (entry)
       type(decay_chain_entry_t), intent(inout), pointer :: entry
       if (associated (entry)) then
          call evaluate (entry%previous)
          call entry%receive_kinematics ()
          call entry%evaluate_trace ()
          call entry%evaluate_event_data ()
       end if
     end subroutine evaluate
   end subroutine decay_chain_evaluate
 
 @ %def decay_chain_evaluate
 @ Return the probability of a decay chain.  This is given as the trace
 of the density matrix with intermediate helicity correlations,
 normalized by the product of the uncorrelated density matrix traces.  This
 works only if an event has been evaluated and the [[correlated_trace]]
 evaluator is filled.  By definition, this evaluator has only one
 matrix element, and this must be real.
 <<Decays: decay chain: TBP>>=
   procedure :: get_probability => decay_chain_get_probability
 <<Decays: procedures>>=
   function decay_chain_get_probability (chain) result (x)
     class(decay_chain_t), intent(in) :: chain
     real(default) :: x
     x = real (chain%correlated_trace%get_matrix_element (1))
   end function decay_chain_get_probability
 
 @ %def decay_chain_get_probability
 @
 \subsection{Decay as Event Transform}
 The [[evt_decay]] object combines decay configuration, decay tree, and
 chain in a single object, as an implementation of the [[evt]] (event
 transform) abstract type.
 
 The [[var_list]] may be a pointer to the user variable list, which
 could contain overridden parameters for the decay processes.
 <<Decays: public>>=
   public :: evt_decay_t
 <<Decays: types>>=
   type, extends (evt_t) :: evt_decay_t
      private
      type(decay_root_config_t) :: decay_root_config
      type(decay_root_t) :: decay_root
      type(decay_chain_t) :: decay_chain
      type(var_list_t), pointer :: var_list => null ()
    contains
    <<Decays: evt decay: TBP>>
   end type evt_decay_t
 
 @ %def evt_decay_t
 @
 <<Decays: evt decay: TBP>>=
   procedure :: write_name => evt_decay_write_name
 <<Decays: procedures>>=
   subroutine evt_decay_write_name (evt, unit)
     class(evt_decay_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A)")  "Event transform: partonic decays"
   end subroutine evt_decay_write_name
 
 @ %def evt_decay_write_name
 @ Output.  We display the currently selected decay tree, which
 includes configuration data, and the decay chain, i.e., the evaluators.
 <<Decays: evt decay: TBP>>=
   procedure :: write => evt_decay_write
 <<Decays: procedures>>=
   subroutine evt_decay_write (evt, unit, verbose, more_verbose, testflag)
     class(evt_decay_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose, more_verbose, testflag
     logical :: verb, verb2
     integer :: u
     u = given_output_unit (unit)
     verb = .true.;  if (present (verbose))  verb = verbose
     verb2 = .false.;  if (present (more_verbose))  verb2 = more_verbose
     call write_separator (u, 2)
     call evt%write_name (u)
     call write_separator (u, 2)
     call evt%base_write (u, testflag = testflag)
     if (associated (evt%var_list)) then
        call write_separator (u)
        write (u, "(1x,A)")  "Variable list for simulation: &
             &[associated, not shown]"
     end if
     if (verb) then
        call write_separator (u)
        call evt%decay_root%write (u)
        if (verb2) then
           call evt%decay_chain%write (u)
           call evt%decay_root%write_process_instances (u, verb)
        end if
     else
        call write_separator (u, 2)
     end if
   end subroutine evt_decay_write
 
 @ %def evt_decay_write
 @ Set the pointer to a user variable list.
 <<Decays: evt decay: TBP>>=
   procedure :: set_var_list => evt_decay_set_var_list
 <<Decays: procedures>>=
   subroutine evt_decay_set_var_list (evt, var_list)
     class(evt_decay_t), intent(inout) :: evt
     type(var_list_t), intent(in), target :: var_list
     evt%var_list => var_list
   end subroutine evt_decay_set_var_list
   
 @ %def evt_decay_set_var_list
 @ Connect with a process instance and process.  This initializes the
 decay configuration.  The process stack is used to look for process
 objects that implement daughter decays.
 
 When all processes are assigned, configure the decay tree instance, using the
 decay tree configuration.  First obtain the branching ratios, then allocate
 the decay tree.  This is done once for all events.
 <<Decays: evt decay: TBP>>=
   procedure :: connect => evt_decay_connect
 <<Decays: procedures>>=
   subroutine evt_decay_connect (evt, process_instance, model, process_stack)
     class(evt_decay_t), intent(inout), target :: evt
     type(process_instance_t), intent(in), target :: process_instance
     class(model_data_t), intent(in), target :: model
     type(process_stack_t), intent(in), optional :: process_stack
     call evt%base_connect (process_instance, model)
     if (associated (evt%var_list)) then
        call evt%decay_root_config%connect (process_instance%process, &
             model, process_stack, process_instance, evt%var_list)
     else
        call evt%decay_root_config%connect (process_instance%process, &
             model, process_stack, process_instance)
     end if
     call evt%decay_root_config%compute ()
     call evt%decay_root%init (evt%decay_root_config, evt%process_instance)
   end subroutine evt_decay_connect
 
 @ %def evt_decay_connect
 @ Prepare a new event: Select a decay chain and build the corresponding chain
 object.
 <<Decays: evt decay: TBP>>=
   procedure :: prepare_new_event => evt_decay_prepare_new_event
 <<Decays: procedures>>=
   subroutine evt_decay_prepare_new_event (evt, i_mci, i_term)
     class(evt_decay_t), intent(inout) :: evt
     integer, intent(in) :: i_mci, i_term
     call evt%reset ()
     evt%decay_root%selected_mci = i_mci
     evt%decay_root%selected_term = i_term
     call evt%decay_root%select_chain ()
     call evt%decay_chain%build (evt%decay_root)
   end subroutine evt_decay_prepare_new_event
 
 @ %def evt_decay_prepare_new_event
 @ Generate a weighted event and assign the resulting weight
 (probability).  We use a chain initialized by the preceding
 subroutine, fill it with momenta and evaluate.
 <<Decays: evt decay: TBP>>=
   procedure :: generate_weighted => evt_decay_generate_weighted
 <<Decays: procedures>>=
   subroutine evt_decay_generate_weighted (evt, probability)
     class(evt_decay_t), intent(inout) :: evt
     real(default), intent(inout) :: probability
     call evt%decay_root%generate ()
     if (signal_is_pending ())  return
     call evt%decay_chain%evaluate ()
     probability = evt%decay_chain%get_probability ()
   end subroutine evt_decay_generate_weighted
 
 @ %def evt_decay_generate_weighted
 @ To create a usable event, we have to transform the interaction into a
 particle set; this requires factorization for the correlated density matrix,
 according to the factorization mode.
 <<Decays: evt decay: TBP>>=
   procedure :: make_particle_set => evt_decay_make_particle_set
 <<Decays: procedures>>=
   subroutine evt_decay_make_particle_set &
        (evt, factorization_mode, keep_correlations, r)
     class(evt_decay_t), intent(inout) :: evt
     integer, intent(in) :: factorization_mode
     logical, intent(in) :: keep_correlations
     real(default), dimension(:), intent(in), optional :: r
     type(interaction_t), pointer :: int_matrix, int_flows
     type(decay_chain_entry_t), pointer :: last_entry
     last_entry => evt%decay_chain%last
     int_matrix => last_entry%get_matrix_int_ptr ()
     int_flows  => last_entry%get_flows_int_ptr ()
     call evt%factorize_interactions (int_matrix, int_flows, &
          factorization_mode, keep_correlations, r)
     call evt%tag_incoming ()
   end subroutine evt_decay_make_particle_set
 
 @ %def event_decay_make_particle_set
 @
 \subsubsection{Auxiliary}
 Eliminate numerical noise for the associated process instances.
 <<Decays: public>>=
   public :: pacify
 <<Decays: interfaces>>=
   interface pacify
      module procedure pacify_decay
      module procedure pacify_decay_gen
      module procedure pacify_term
      module procedure pacify_unstable
   end interface pacify
 <<Decays: procedures>>=
   subroutine pacify_decay (evt)
     class(evt_decay_t), intent(inout) :: evt
     call pacify_decay_gen (evt%decay_root)
   end subroutine pacify_decay
 
   recursive subroutine pacify_decay_gen (decay)
     class(decay_gen_t), intent(inout) :: decay
     if (associated (decay%process_instance)) then
        call pacify (decay%process_instance)
     end if
     if (decay%selected_term > 0) then
        call pacify_term (decay%term(decay%selected_term))
     end if
   end subroutine pacify_decay_gen
 
   recursive subroutine pacify_term (term)
     class(decay_term_t), intent(inout) :: term
     integer :: i
     do i = 1, size (term%particle_out)
        select type (unstable => term%particle_out(i)%c)
        type is (unstable_t);  call pacify_unstable (unstable)
        end select
     end do
   end subroutine pacify_term
 
   recursive subroutine pacify_unstable (unstable)
     class(unstable_t), intent(inout) :: unstable
     if (unstable%selected_decay > 0) then
        call pacify_decay_gen (unstable%decay(unstable%selected_decay))
     end if
   end subroutine pacify_unstable
 
 @ %def pacify
 @ Prepare specific configurations for use in unit tests.
 <<Decays: unstable config: TBP>>=
   procedure :: init_test_case1
   procedure :: init_test_case2
 <<Decays: procedures>>=
   subroutine init_test_case1 (unstable, i, flv, integral, relerr, model)
     class(unstable_config_t), intent(inout) :: unstable
     integer, intent(in) :: i
     type(flavor_t), dimension(:,:), intent(in) :: flv
     real(default), intent(in) :: integral
     real(default), intent(in) :: relerr
     class(model_data_t), intent(in), target :: model
     associate (decay => unstable%decay_config(i))
       allocate (decay%term_config (1))
       call decay%init_term (1, flv, stable = [.true., .true.], model=model)
       decay%integral = integral
       decay%abs_error = integral * relerr
     end associate
   end subroutine init_test_case1
 
   subroutine init_test_case2 (unstable, flv1, flv21, flv22, model)
     class(unstable_config_t), intent(inout) :: unstable
     type(flavor_t), dimension(:,:), intent(in) :: flv1, flv21, flv22
     class(model_data_t), intent(in), target :: model
     associate (decay => unstable%decay_config(1))
       decay%integral = 1.e-3_default
       decay%abs_error = decay%integral * .01_default
 
       allocate (decay%term_config (1))
       call decay%init_term (1, flv1, stable = [.false., .true.], model=model)
 
       select type (w => decay%term_config(1)%prt(1)%c)
       type is (unstable_config_t)
 
          associate (w_decay => w%decay_config(1))
            w_decay%integral = 2._default
            allocate (w_decay%term_config (1))
            call w_decay%init_term (1, flv21, stable = [.true., .true.], &
                 model=model)
          end associate
          associate (w_decay => w%decay_config(2))
            w_decay%integral = 1._default
            allocate (w_decay%term_config (1))
            call w_decay%init_term (1, flv22, stable = [.true., .true.], &
                 model=model)
          end associate
          call w%compute ()
 
       end select
     end associate
   end subroutine init_test_case2
 
 @ %def init_test_case1
 @ %def init_test_case2
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[decays_ut.f90]]>>=
 <<File header>>
 
 module decays_ut
   use unit_tests
   use decays_uti
 
 <<Standard module head>>
 
 <<Decays: public test>>
 
 <<Decays: public test auxiliary>>
 
 contains
 
 <<Decays: test driver>>
 
 end module decays_ut
 @ %def decays_ut
 @
 <<[[decays_uti.f90]]>>=
 <<File header>>
 
 module decays_uti
 
 <<Use kinds>>
 <<Use strings>>
   use os_interface
   use sm_qcd
   use model_data
   use state_matrices, only: FM_IGNORE_HELICITY
   use interactions, only: reset_interaction_counter
   use flavors
   use process_libraries
   use rng_base
   use mci_base
   use mci_midpoint
   use phs_base
   use phs_single
   use prc_core
   use prc_test, only: prc_test_create_library
   use process, only: process_t
   use instances, only: process_instance_t
   use process_stacks
 
   use decays
 
   use rng_base_ut, only: rng_test_t, rng_test_factory_t
 
 <<Standard module head>>
 
 <<Decays: public test auxiliary>>
 
 <<Decays: test declarations>>
 
 contains
 
 <<Decays: tests>>
 
 <<Decays: test auxiliary>>
 
 end module decays_uti
 
 @ %def decays_uti
 @ API: driver for the unit tests below.
 <<Decays: public test>>=
   public :: decays_test
 <<Decays: test driver>>=
   subroutine decays_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Decays: execute tests>>
   end subroutine decays_test
 
 @ %def decays_test
 @
 \subsubsection{Testbed}
 As a variation of the [[prepare_test_process]] routine used elsewhere, we
 define here a routine that creates two processes (scattering $ss\to ss$ and
 decay $s\to f\bar f$), compiles and integrates them and prepares for event
 generation.
 <<Decays: public test auxiliary>>=
   public :: prepare_testbed
 <<Decays: test auxiliary>>=
   subroutine prepare_testbed &
        (lib, process_stack, prefix, os_data, &
         scattering, decay, decay_rest_frame)
     type(process_library_t), intent(out), target :: lib
     type(process_stack_t), intent(out) :: process_stack
     type(string_t), intent(in) :: prefix
     type(os_data_t), intent(in) :: os_data
     logical, intent(in) :: scattering, decay
     logical, intent(in), optional :: decay_rest_frame
 
     type(model_data_t), target :: model
     class(model_data_t), pointer :: model_copy
     type(string_t) :: libname, procname1, procname2, run_id
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     type(process_entry_t), pointer :: process
     type(process_instance_t), allocatable, target :: process_instance
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     type(field_data_t), pointer :: field_data
     real(default) :: sqrts
 
     libname = prefix // "_lib"
     procname1 = prefix // "_p"
     procname2 = prefix // "_d"
     run_id = prefix
 
     call model%init_test ()
     call model%set_par (var_str ("ff"), 0.4_default)
     call model%set_par (var_str ("mf"), &
          model%get_real (var_str ("ff")) * model%get_real (var_str ("ms")))
 
     if (scattering .and. decay) then
        field_data => model%get_field_ptr (25)
        call field_data%set (p_is_stable = .false.)
     end if
 
     call prc_test_create_library (libname, lib, &
          scattering = .true., decay = .true., &
          procname1 = procname1, procname2 = procname2)
 
     call reset_interaction_counter ()
 
     allocate (mci_midpoint_t :: mci_template)
     allocate (phs_single_config_t :: phs_config_template)
 
     if (scattering) then
 
        allocate (rng_test_factory_t :: rng_factory)
        allocate (model_copy)
        call model_copy%init (model%get_name (), &
             model%get_n_real (), &
             model%get_n_complex (), &
             model%get_n_field (), &
             model%get_n_vtx ())
        call model_copy%copy_from (model)
 
        allocate (process)
        call process%init (procname1, &
             run_id, lib, os_data, qcd, rng_factory, model_copy)
        call process%setup_test_cores ()
        call process%init_component &
           (1, .true., mci_template, phs_config_template)
        sqrts = 1000
        call process%setup_beams_sqrts (sqrts, i_core = 1)
        call process%configure_phs ()
        call process%setup_mci ()
        call process%setup_terms ()
 
        allocate (process_instance)
        call process_instance%init (process%process_t)
        call process_instance%integrate (1, n_it = 1, n_calls = 100)
        call process%final_integration (1)
        call process_instance%final ()
        deallocate (process_instance)
 
        call process%prepare_simulation (1)
        call process_stack%push (process)
     end if
 
     if (decay) then
        allocate (rng_test_factory_t :: rng_factory)
        allocate (model_copy)
        call model_copy%init (model%get_name (), &
             model%get_n_real (), &
             model%get_n_complex (), &
             model%get_n_field (), &
             model%get_n_vtx ())
        call model_copy%copy_from (model)
 
        allocate (process)
        call process%init (procname2, &
             run_id, lib, os_data, qcd, rng_factory, model_copy)
        call process%setup_test_cores ()
        call process%init_component &
           (1, .true., mci_template, phs_config_template)
        if (present (decay_rest_frame)) then
           call process%setup_beams_decay (rest_frame = decay_rest_frame, i_core = 1)
        else
           call process%setup_beams_decay (rest_frame = .not. scattering, i_core = 1)
        end if
        call process%configure_phs ()
        call process%setup_mci ()
        call process%setup_terms ()
 
        allocate (process_instance)
        call process_instance%init (process%process_t)
        call process_instance%integrate (1, n_it=1, n_calls=100)
        call process%final_integration (1)
        call process_instance%final ()
        deallocate (process_instance)
 
        call process%prepare_simulation (1)
        call process_stack%push (process)
     end if
 
     call model%final ()
 
   end subroutine prepare_testbed
 
 @ %def prepare_testbed
 @
 \subsubsection{Simple decay configuration}
 We define a branching configuration with two decay modes.  We set the
 integral values by hand, so we do not need to evaluate processes, yet.
 <<Decays: execute tests>>=
   call test (decays_1, "decays_1", &
        "branching and decay configuration", &
        u, results)
 <<Decays: test declarations>>=
   public :: decays_1
 <<Decays: tests>>=
   subroutine decays_1 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(model_data_t), target :: model
     type(flavor_t) :: flv_h
     type(flavor_t), dimension(2,1) :: flv_hbb, flv_hgg
     type(unstable_config_t), allocatable :: unstable
 
     write (u, "(A)")  "* Test output: decays_1"
     write (u, "(A)")  "*   Purpose: Set up branching and decay configuration"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call os_data_init (os_data)
     call model%init_sm_test ()
 
     call flv_h%init (25, model)
     call flv_hbb(:,1)%init ([5, -5], model)
     call flv_hgg(:,1)%init ([22, 22], model)
 
     write (u, "(A)")  "* Set up branching and decay"
     write (u, "(A)")
 
     allocate (unstable)
     call unstable%init (flv_h)
     call unstable%init_decays ([var_str ("h_bb"), var_str ("h_gg")], model)
 
     call unstable%init_test_case1 &
          (1, flv_hbb, 1.234e-3_default, .02_default, model)
 
     call unstable%init_test_case1 &
          (2, flv_hgg, 3.085e-4_default, .08_default, model)
 
     call unstable%compute ()
     call unstable%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call unstable%final ()
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: decays_1"
 
   end subroutine decays_1
 
 @ %def decays_1
 @
 \subsubsection{Cascade decay configuration}
 We define a branching configuration with one decay, which is followed
 by another branching.
 <<Decays: execute tests>>=
   call test (decays_2, "decays_2", &
        "cascade decay configuration", &
        u, results)
 <<Decays: test declarations>>=
   public :: decays_2
 <<Decays: tests>>=
   subroutine decays_2 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(model_data_t), target :: model
     type(flavor_t) :: flv_h, flv_wp, flv_wm
     type(flavor_t), dimension(2,1) :: flv_hww, flv_wud, flv_wen
     type(unstable_config_t), allocatable :: unstable
 
     write (u, "(A)")  "* Test output: decays_2"
     write (u, "(A)")  "*   Purpose: Set up cascade branching"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call os_data_init (os_data)
     call model%init_sm_test ()
 
     call model%set_unstable (25, [var_str ("h_ww")])
     call model%set_unstable (24, [var_str ("w_ud"), var_str ("w_en")])
 
     call flv_h%init (25, model)
     call flv_hww(:,1)%init ([24, -24], model)
     call flv_wp%init (24, model)
     call flv_wm%init (-24, model)
     call flv_wud(:,1)%init ([2, -1], model)
     call flv_wen(:,1)%init ([-11, 12], model)
 
 
     write (u, "(A)")  "* Set up branching and decay"
     write (u, "(A)")
 
     allocate (unstable)
     call unstable%init (flv_h, set_decays=.true., model=model)
 
     call unstable%init_test_case2 (flv_hww, flv_wud, flv_wen, model)
 
     call unstable%compute ()
     call unstable%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call unstable%final ()
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: decays_2"
 
   end subroutine decays_2
 
 @ %def decays_2
 @
 \subsubsection{Decay and Process Object}
 We define a branching configuration with one decay and connect this
 with an actual process object.
 <<Decays: execute tests>>=
   call test (decays_3, "decays_3", &
        "associate process", &
        u, results)
 <<Decays: test declarations>>=
   public :: decays_3
 <<Decays: tests>>=
   subroutine decays_3 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     class(model_data_t), pointer :: model
     type(process_library_t), target :: lib
     type(string_t) :: prefix
     type(string_t) :: procname2
     type(process_stack_t) :: process_stack
     type(process_t), pointer :: process
     type(unstable_config_t), allocatable :: unstable
     type(flavor_t) :: flv
 
     write (u, "(A)")  "* Test output: decays_3"
     write (u, "(A)")  "*   Purpose: Connect a decay configuration &
          &with a process"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment and integrate process"
     write (u, "(A)")
 
     call os_data_init (os_data)
 
     prefix = "decays_3"
     call prepare_testbed &
          (lib, process_stack, prefix, os_data, &
          scattering=.false., decay=.true., decay_rest_frame=.false.)
 
     procname2 = prefix // "_d"
     process => process_stack%get_process_ptr (procname2)
     model => process%get_model_ptr ()
     call process%write (.false., u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Set up branching and decay"
     write (u, "(A)")
 
     call flv%init (25, model)
 
     allocate (unstable)
     call unstable%init (flv)
     call unstable%init_decays ([procname2], model)
 
     write (u, "(A)")  "* Connect decay with process object"
     write (u, "(A)")
 
     call unstable%connect_decay (1, process, model)
 
     call unstable%compute ()
     call unstable%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call unstable%final ()
     call process_stack%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: decays_3"
 
   end subroutine decays_3
 
 @ %def decays_3
 @
 \subsubsection{Decay and Process Object}
 Building upon the previous test, we set up a decay instance and generate a
 decay event.
 <<Decays: execute tests>>=
   call test (decays_4, "decays_4", &
        "decay instance", &
        u, results)
 <<Decays: test declarations>>=
   public :: decays_4
 <<Decays: tests>>=
   subroutine decays_4 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     class(model_data_t), pointer :: model
     type(process_library_t), target :: lib
     type(string_t) :: prefix, procname2
     class(rng_t), allocatable :: rng
     type(process_stack_t) :: process_stack
     type(process_t), pointer :: process
     type(unstable_config_t), allocatable, target :: unstable
     type(flavor_t) :: flv
     type(unstable_t), allocatable :: instance
 
     write (u, "(A)")  "* Test output: decays_4"
     write (u, "(A)")  "*   Purpose: Create a decay process and evaluate &
          &an instance"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment, process, &
          &and decay configuration"
     write (u, "(A)")
 
     call os_data_init (os_data)
 
     prefix = "decays_4"
     call prepare_testbed &
          (lib, process_stack, prefix, os_data, &
          scattering=.false., decay=.true., decay_rest_frame = .false.)
 
     procname2 = prefix // "_d"
     process => process_stack%get_process_ptr (procname2)
     model => process%get_model_ptr ()
 
     call flv%init (25, model)
 
     allocate (unstable)
     call unstable%init (flv)
     call unstable%init_decays ([procname2], model)
 
     call model%set_unstable (25, [procname2])
 
     call unstable%connect_decay (1, process, model)
 
     call unstable%compute ()
 
     allocate (rng_test_t :: rng)
 
     allocate (instance)
     call instance%init (unstable)
     call instance%import_rng (rng)
 
     call instance%select_chain ()
     call instance%generate ()
     call instance%write (u)
 
     write (u, *)
     call instance%write_process_instances (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call instance%final ()
     call process_stack%final ()
     call unstable%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: decays_4"
 
   end subroutine decays_4
 
 @ %def decays_4
 @
 \subsubsection{Decay with Parent Process}
 We define a scattering process $ss\to ss$ and subsequent decays $s\to f\bar
 f$.
 <<Decays: execute tests>>=
   call test (decays_5, "decays_5", &
        "parent process and decay", &
        u, results)
 <<Decays: test declarations>>=
   public :: decays_5
 <<Decays: tests>>=
   subroutine decays_5 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     class(model_data_t), pointer :: model
     type(process_library_t), target :: lib
     type(string_t) :: prefix, procname1, procname2
     type(process_stack_t) :: process_stack
     type(process_t), pointer :: process
     type(process_instance_t), allocatable, target :: process_instance
     type(decay_root_config_t), target :: decay_root_config
     type(decay_root_t) :: decay_root
     type(decay_chain_t) :: decay_chain
 
     write (u, "(A)")  "* Test output: decays_5"
     write (u, "(A)")  "*   Purpose: Handle a process with subsequent decays"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment and parent process"
     write (u, "(A)")
 
     call os_data_init (os_data)
 
     prefix = "decays_5"
     procname1 = prefix // "_p"
     procname2 = prefix // "_d"
     call prepare_testbed &
          (lib, process_stack, prefix, os_data, &
          scattering=.true., decay=.true.)
 
     write (u, "(A)")  "* Initialize decay process"
     write (u, "(A)")
 
     process => process_stack%get_process_ptr (procname1)
     model => process%get_model_ptr ()
     call model%set_unstable (25, [procname2])
 
     write (u, "(A)")  "* Initialize decay tree configuration"
     write (u, "(A)")
 
     call decay_root_config%connect (process, model, process_stack)
     call decay_root_config%compute ()
     call decay_root_config%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Initialize decay tree"
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%setup_event_data ()
     call process_instance%init_simulation (1)
 
     call decay_root%init (decay_root_config, process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Select decay chain"
     write (u, "(A)")
 
     call decay_root%set_mci (1)
     !!! Not yet implemented; there is only one term anyway:
     ! call process_instance%select_i_term (decay_root%selected_term)
     call decay_root%set_term (1)
     call decay_root%select_chain ()
 
     call decay_chain%build (decay_root)
 
     call decay_root%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Generate event"
     write (u, "(A)")
 
     call process_instance%generate_unweighted_event (decay_root%get_mci ())
     call process_instance%evaluate_event_data ()
 
     call decay_root%generate ()
 
     call pacify (decay_root)
 
     write (u, "(A)")  "* Process instances"
     write (u, "(A)")
 
     call decay_root%write_process_instances (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Generate decay chain"
     write (u, "(A)")
 
     call decay_chain%evaluate ()
     call decay_chain%write (u)
 
     write (u, *)
     write (u, "(A,ES19.12)")  "chain probability =", &
          decay_chain%get_probability ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call decay_chain%final ()
     call decay_root%final ()
     call decay_root_config%final ()
     call process_instance%final ()
     deallocate (process_instance)
 
     call process%final ()
     call process_stack%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: decays_5"
 
   end subroutine decays_5
 
 @ %def decays_5
 @
 \subsubsection{Decay as Event Transform}
 Again, we define a scattering process $ss\to ss$ and subsequent decays
 $s\to f\bar f$.
 <<Decays: execute tests>>=
   call test (decays_6, "decays_6", &
        "evt_decay object", &
        u, results)
 <<Decays: test declarations>>=
   public :: decays_6
 <<Decays: tests>>=
   subroutine decays_6 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     class(model_data_t), pointer :: model
     type(process_library_t), target :: lib
     type(string_t) :: prefix, procname1, procname2
     type(process_stack_t) :: process_stack
     type(process_t), pointer :: process
     type(process_instance_t), allocatable, target :: process_instance
     type(evt_decay_t), target :: evt_decay
     integer :: factorization_mode
     logical :: keep_correlations
 
     write (u, "(A)")  "* Test output: decays_6"
     write (u, "(A)")  "*   Purpose: Handle a process with subsequent decays"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment and parent process"
     write (u, "(A)")
 
     call os_data_init (os_data)
 
     prefix = "decays_6"
     procname1 = prefix // "_p"
     procname2 = prefix // "_d"
     call prepare_testbed &
          (lib, process_stack, prefix, os_data, &
          scattering=.true., decay=.true.)
 
     write (u, "(A)")  "* Initialize decay process"
 
     process => process_stack%get_process_ptr (procname1)
     model => process%get_model_ptr ()
     call model%set_unstable (25, [procname2])
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%setup_event_data ()
     call process_instance%init_simulation (1)
 
     write (u, "(A)")
     write (u, "(A)")  "* Initialize decay object"
 
     call evt_decay%connect (process_instance, model, process_stack)
 
     write (u, "(A)")
     write (u, "(A)")  "* Generate scattering event"
 
     call process_instance%generate_unweighted_event (1)
     call process_instance%evaluate_event_data ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Select decay chain and generate event"
     write (u, "(A)")
 
     call evt_decay%prepare_new_event (1, 1)
     call evt_decay%generate_unweighted ()
 
     factorization_mode = FM_IGNORE_HELICITY
     keep_correlations = .false.
     call evt_decay%make_particle_set (factorization_mode, keep_correlations)
 
     call evt_decay%write (u, verbose = .true.)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_decay%final ()
     call process_instance%final ()
     deallocate (process_instance)
 
     call process_stack%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: decays_6"
 
   end subroutine decays_6
 
 @ %def decays_6
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Tau decays}
 <<[[tau_decays.f90]]>>=
 <<File header>>
 
 module tau_decays
 
 <<Use kinds>>
   use io_units
   use format_utils, only: write_separator
   use sm_qcd
   use model_data
   use models
   use event_transforms
 
 <<Standard module head>>
 
 <<Tau decays: public>>
 
 <<Tau decays: types>>
 
 contains
 
 <<Tau decays: procedures>>
 
 end module tau_decays
 @ %def tau_decays
 \subsection{Tau Decays Event Transform}
 This is the type for the tau decay event transform.
 <<Tau decays: public>>=
   public :: evt_tau_decays_t
 <<Tau decays: types>>=
   type, extends (evt_t) :: evt_tau_decays_t
      type(model_t), pointer :: model_hadrons => null()
      type(qcd_t), pointer :: qcd_t => null()
    contains
    <<Tau decays: evt tau decays: TBP>>
   end type evt_tau_decays_t
 
 @ %def evt_tau_decays_t
 <<Tau decays: evt tau decays: TBP>>=
   procedure :: write_name => evt_tau_decays_write_name
 <<Tau decays: procedures>>=
   subroutine evt_tau_decays_write_name (evt, unit)
     class(evt_tau_decays_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A)")  "Event transform: tau decays"
   end subroutine evt_tau_decays_write_name
 
 @ %def evt_tau_decays_write_name
 @ Output.
 <<Tau decays: evt tau decays: TBP>>=
   procedure :: write => evt_tau_decays_write
 <<Tau decays: procedures>>=
   subroutine evt_tau_decays_write (evt, unit, verbose, more_verbose, testflag)
     class(evt_tau_decays_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose, more_verbose, testflag
     integer :: u
     u = given_output_unit (unit)
     call write_separator (u, 2)
     call evt%write_name (u)
     call write_separator (u)
     call evt%base_write (u, testflag = testflag, show_set = .false.)
     if (evt%particle_set_exists)  &
          call evt%particle_set%write &
          (u, summary = .true., compressed = .true., testflag = testflag)
     call write_separator (u)
   end subroutine evt_tau_decays_write
 
 @ %def evt_tau_decays_write
 @ Here we take the particle set from the previous event transform and
 apply the tau decays. What probability should be given back, the
 product of branching ratios of the corresponding tau decays?
 <<Tau decays: evt tau decays: TBP>>=
   procedure :: generate_weighted => evt_tau_decays_generate_weighted
 <<Tau decays: procedures>>=
   subroutine evt_tau_decays_generate_weighted (evt, probability)
     class(evt_tau_decays_t), intent(inout) :: evt
     real(default), intent(inout) :: probability
     logical :: valid
     evt%particle_set = evt%previous%particle_set
     !!! To be checked or expanded
     probability = 1
     valid = .true.
     evt%particle_set_exists = valid
   end subroutine evt_tau_decays_generate_weighted
 
 @ %def evt_tau_decays_generate_weighted
 @ The factorization parameters are irrelevant.
 <<Tau decays: evt tau decays: TBP>>=
   procedure :: make_particle_set => evt_tau_decays_make_particle_set
 <<Tau decays: procedures>>=
   subroutine evt_tau_decays_make_particle_set &
        (evt, factorization_mode, keep_correlations, r)
     class(evt_tau_decays_t), intent(inout) :: evt
     integer, intent(in) :: factorization_mode
     logical, intent(in) :: keep_correlations
     real(default), dimension(:), intent(in), optional :: r
     logical :: valid
     !!! to be checked and expanded
     valid = .true.
     evt%particle_set_exists = evt%particle_set_exists .and. valid
   end subroutine evt_tau_decays_make_particle_set
 
 @ %def event_tau_decays_make_particle_set
 @
 <<Tau decays: evt tau decays: TBP>>=
   procedure :: prepare_new_event => evt_tau_decays_prepare_new_event
 <<Tau decays: procedures>>=
   subroutine evt_tau_decays_prepare_new_event (evt, i_mci, i_term)
     class(evt_tau_decays_t), intent(inout) :: evt
     integer, intent(in) :: i_mci, i_term
     call evt%reset ()
   end subroutine evt_tau_decays_prepare_new_event
 
 @ %def evt_tau_decays_prepare_new_event
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Shower}
 We might use matrix elements of LO and NLO to increase the accuracy of
 the shower in the sense of matching as well as merging.
 <<[[shower.f90]]>>=
 <<File header>>
 
 module shower
 
 <<Use kinds>>
 <<Use strings>>
   use io_units
   use format_utils, only: write_separator
   use system_defs, only: LF
   use os_interface
   use diagnostics
   use lorentz
   use pdf
   use subevents, only: PRT_BEAM_REMNANT, PRT_INCOMING, PRT_OUTGOING
 
   use shower_base
   use matching_base
   use powheg_matching, only: powheg_matching_t
 
   use sm_qcd
   use model_data
   use rng_base
 
   use event_transforms
   use models
   use hep_common
   use process, only: process_t
   use instances, only: process_instance_t
   use process_stacks
 
 <<Standard module head>>
 
 <<Shower: public>>
 
 <<Shower: parameters>>
 
 <<Shower: types>>
 
 contains
 
 <<Shower: procedures>>
 
 end module shower
 @ %def shower
 @
 \subsection{Configuration Parameters}
 [[POWHEG_TESTING]] allows to disable the parton shower for validation
 and testing of the POWHEG procedure.
 <<Shower: parameters>>=
   logical, parameter :: POWHEG_TESTING = .false.
 
 @ %def POWHEG_TESTING
 @
 \subsection{Event Transform}
 The event transforms can do more than mere showering.  Especially, it
 may reweight showered events to fixed-order matrix elements.  The
 [[model_hadrons]] is supposed to be the SM variant that contains all
 hadrons that can be generated in the shower.
 <<Shower: public>>=
   public :: evt_shower_t
 <<Shower: types>>=
   type, extends (evt_t) :: evt_shower_t
      class(shower_base_t), allocatable :: shower
      class(matching_t), allocatable :: matching
      type(model_t), pointer :: model_hadrons => null ()
      type(qcd_t), pointer :: qcd => null()
      type(pdf_data_t) :: pdf_data
      type(os_data_t) :: os_data
      logical :: is_first_event
    contains
    <<Shower: evt shower: TBP>>
   end type evt_shower_t
 
 @ %def evt_shower_t
 @
 <<Shower: evt shower: TBP>>=
   procedure :: write_name => evt_shower_write_name
 <<Shower: procedures>>=
   subroutine evt_shower_write_name (evt, unit)
     class(evt_shower_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A)")  "Event transform: shower"
   end subroutine evt_shower_write_name
 
 @ %def evt_shower_write_name
 @ Output.
 <<Shower: evt shower: TBP>>=
   procedure :: write => evt_shower_write
 <<Shower: procedures>>=
   subroutine evt_shower_write (evt, unit, verbose, more_verbose, testflag)
     class(evt_shower_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose, more_verbose, testflag
     integer :: u
     u = given_output_unit (unit)
     call write_separator (u, 2)
     call evt%write_name (u)
     call write_separator (u)
     call evt%base_write (u, testflag = testflag, show_set = .false.)
     if (evt%particle_set_exists)  call evt%particle_set%write &
          (u, summary = .true., compressed = .true., testflag = testflag)
     call write_separator (u)
     call evt%shower%settings%write (u)
   end subroutine evt_shower_write
 
 @ %def evt_shower_write
 <<Shower: evt shower: TBP>>=
   procedure :: connect => evt_shower_connect
 <<Shower: procedures>>=
   subroutine evt_shower_connect &
        (evt, process_instance, model, process_stack)
     class(evt_shower_t), intent(inout), target :: evt
     type(process_instance_t), intent(in), target :: process_instance
     class(model_data_t), intent(in), target :: model
     type(process_stack_t), intent(in), optional :: process_stack
     call evt%base_connect (process_instance, model, process_stack)
     call evt%make_rng (evt%process)
     if (allocated (evt%matching)) then
        call evt%matching%connect (process_instance, model, evt%shower)
     end if
   end subroutine evt_shower_connect
 
 @ %def evt_shower_connect
 @ Initialize the event transformation.  This will be executed once
 during dispatching.  The [[model_hadrons]] is supposed to be the SM
 variant that contains all hadrons that may be generated in the
 shower.
 <<Shower: evt shower: TBP>>=
   procedure :: init => evt_shower_init
 <<Shower: procedures>>=
   subroutine evt_shower_init (evt, model_hadrons, os_data)
     class(evt_shower_t), intent(out) :: evt
     type(model_t), intent(in), target :: model_hadrons
     type(os_data_t), intent(in) :: os_data
     evt%os_data = os_data
     evt%model_hadrons => model_hadrons
     evt%is_first_event = .true.
   end subroutine evt_shower_init
 
 @ %def evt_shower_init
 @ Create RNG instances, spawned by the process object.
 <<Shower: evt shower: TBP>>=
   procedure :: make_rng => evt_shower_make_rng
 <<Shower: procedures>>=
   subroutine evt_shower_make_rng (evt, process)
     class(evt_shower_t), intent(inout) :: evt
     type(process_t), intent(inout) :: process
     class(rng_t), allocatable :: rng
     call process%make_rng (rng)
     call evt%shower%import_rng (rng)
     if (allocated (evt%matching)) then
        call process%make_rng (rng)
        call evt%matching%import_rng (rng)
     end if
   end subroutine evt_shower_make_rng
 
 @ %def evt_shower_make_rng
 @ Things we want to do for a new event before the whole event
 transformation chain is evaluated.
 <<Shower: evt shower: TBP>>=
   procedure :: prepare_new_event => evt_shower_prepare_new_event
 <<Shower: procedures>>=
   subroutine evt_shower_prepare_new_event (evt, i_mci, i_term)
     class(evt_shower_t), intent(inout) :: evt
     integer, intent(in) :: i_mci, i_term
     call evt%reset ()
     call evt%shower%prepare_new_event ()
   end subroutine evt_shower_prepare_new_event
 
 @ %def evt_shower_prepare_new_event
 @
 <<Shower: evt shower: TBP>>=
   procedure :: first_event => evt_shower_first_event
 <<Shower: procedures>>=
   subroutine evt_shower_first_event (evt)
     class(evt_shower_t), intent(inout) :: evt
     double precision :: pdftest
     call msg_debug (D_TRANSFORMS, "evt_shower_first_event")
     associate (settings => evt%shower%settings)
        settings%hadron_collision = .false.
        !!! !!! !!! Workaround for PGF90 v16.1
        !!! if (all (evt%particle_set%prt(1:2)%flv%get_pdg_abs () <= 39)) then
        if (evt%particle_set%prt(1)%flv%get_pdg_abs () <= 39 .and. &
            evt%particle_set%prt(2)%flv%get_pdg_abs () <= 39) then
           settings%hadron_collision = .false.
        !!! else if (all (evt%particle_set%prt(1:2)%flv%get_pdg_abs () >= 100)) then
        else if (evt%particle_set%prt(1)%flv%get_pdg_abs () >= 100 .and. &
                 evt%particle_set%prt(2)%flv%get_pdg_abs () >= 100) then
           settings%hadron_collision = .true.
        else
           call msg_fatal ("evt_shower didn't recognize beams setup")
        end if
        call msg_debug (D_TRANSFORMS, "hadron_collision", settings%hadron_collision)
        if (allocated (evt%matching)) then
           evt%matching%is_hadron_collision = settings%hadron_collision
           call evt%matching%first_event ()
        end if
        if (.not. settings%hadron_collision .and. settings%isr_active) then
           call msg_fatal ("?ps_isr_active is only intended for hadron-collisions")
        end if
        if (evt%pdf_data%type == STRF_LHAPDF5) then
           if (settings%isr_active .and. settings%hadron_collision) then
              call GetQ2max (0, pdftest)
              if (pdftest < epsilon (pdftest)) then
                 call msg_bug ("ISR QCD shower enabled, but LHAPDF not " // &
                      "initialized," // LF // "     aborting simulation")
                 return
              end if
           end if
        else if (evt%pdf_data%type == STRF_PDF_BUILTIN .and. &
                 settings%method == PS_PYTHIA6) then
           call msg_fatal ("Builtin PDFs cannot be used for PYTHIA showers," &
                // LF // "     aborting simulation")
           return
        end if
     end associate
     evt%is_first_event = .false.
   end subroutine evt_shower_first_event
 
 @ %def evt_shower_first_event
 @ Here we take the particle set from the previous event transform
 (assuming that there is always one) and apply the shower algorithm.  The
 result is stored in the event transform of the current object.  We
 always return a probability of unity as we don't have the analytic
 weight of the combination of shower, MLM matching and hadronization.  A
 subdivision into multiple event transformations is under construction.
 Invalid or vetoed events have to be discarded by the caller which is why
 we mark the particle set as invalid. This procedure directly takes the
 (MLM) matching into account.
 <<Shower: evt shower: TBP>>=
   procedure :: generate_weighted => evt_shower_generate_weighted
 <<Shower: procedures>>=
   subroutine evt_shower_generate_weighted (evt, probability)
     class(evt_shower_t), intent(inout) :: evt
     real(default), intent(inout) :: probability
     logical :: valid, vetoed
     integer :: i_term
     real(default) :: fac_scale
     call msg_debug (D_TRANSFORMS, "evt_shower_generate_weighted")
     if (signal_is_pending ())  return
     i_term = 1
     evt%particle_set = evt%previous%particle_set
     valid = .true.;  vetoed = .false.
     fac_scale = evt%process_instance%get_fac_scale (i_term)
     if (evt%is_first_event)  call evt%first_event ()
     call evt%shower%import_particle_set &
          (evt%particle_set, evt%os_data, fac_scale)
     if (allocated (evt%matching)) then
        call evt%matching%before_shower (evt%particle_set, vetoed)
        if (msg_level(D_TRANSFORMS) >= DEBUG) then
           call msg_debug (D_TRANSFORMS, "Matching before generate emissions")
           call evt%matching%write ()
        end if
     end if
     if (.not. (vetoed .or. POWHEG_TESTING)) then
        if (evt%shower%settings%method == PS_PYTHIA6 .or. &
            evt%shower%settings%hadronization_active) then
           call assure_heprup (evt%particle_set)
        end if
        call evt%shower%generate_emissions (valid)
     end if
     probability = 1
     evt%particle_set_exists = valid .and. .not. vetoed
   end subroutine evt_shower_generate_weighted
 
 @ %def evt_shower_generate_weighted
 @ Here, we fill the particle set with the partons from the shower.
 The factorization parameters are irrelevant.
 We make a sanity check that the initial energy lands either in the
 outgoing particles or add to the beam remnant.
 <<Shower: evt shower: TBP>>=
   procedure :: make_particle_set => evt_shower_make_particle_set
 <<Shower: procedures>>=
   subroutine evt_shower_make_particle_set &
        (evt, factorization_mode, keep_correlations, r)
     class(evt_shower_t), intent(inout) :: evt
     integer, intent(in) :: factorization_mode
     logical, intent(in) :: keep_correlations
     real(default), dimension(:), intent(in), optional :: r
     type(vector4_t) :: sum_vec_in, sum_vec_out, sum_vec_beamrem, &
          sum_vec_beamrem_before
     logical :: vetoed, sane
     if (evt%particle_set_exists) then
        vetoed = .false.
        sum_vec_beamrem_before = sum (evt%particle_set%prt%p, &
             mask=evt%particle_set%prt%get_status () == PRT_BEAM_REMNANT)
        call evt%shower%make_particle_set (evt%particle_set, &
             evt%model, evt%model_hadrons)
        if (allocated (evt%matching)) then
           call evt%matching%after_shower (evt%particle_set, vetoed)
        end if
        if (debug_active (D_TRANSFORMS)) then
           call msg_debug (D_TRANSFORMS, &
                "Shower: obtained particle set after shower + matching")
           call evt%particle_set%write (summary = .true., compressed = .true.)
        end if
        sum_vec_in = sum (evt%particle_set%prt%p, &
             mask=evt%particle_set%prt%get_status () == PRT_INCOMING)
        sum_vec_out = sum (evt%particle_set%prt%p, &
             mask=evt%particle_set%prt%get_status () == PRT_OUTGOING)
        sum_vec_beamrem = sum (evt%particle_set%prt%p, &
             mask=evt%particle_set%prt%get_status () == PRT_BEAM_REMNANT)
        sum_vec_beamrem = sum_vec_beamrem - sum_vec_beamrem_before
        sane = abs(sum_vec_out%p(0) - sum_vec_in%p(0)) < &
             sum_vec_in%p(0) / 10 .or. &
             abs((sum_vec_out%p(0) + sum_vec_beamrem%p(0)) - sum_vec_in%p(0)) < &
             sum_vec_in%p(0) / 10
        sane = .true.
        evt%particle_set_exists = .not. vetoed .and. sane
     end if
   end subroutine evt_shower_make_particle_set
 
 @ %def event_shower_make_particle_set
 @
 <<Shower: evt shower: TBP>>=
   procedure :: contains_powheg_matching => evt_shower_contains_powheg_matching
 <<Shower: procedures>>=
   function evt_shower_contains_powheg_matching (evt) result (val)
      logical :: val
      class(evt_shower_t), intent(in) :: evt
      val = .false.
      if (allocated (evt%matching)) &
         val = evt%matching%get_method () == "POWHEG"
   end function evt_shower_contains_powheg_matching
 
 @ %def evt_shower_contains_powheg_matching
 @
 <<Shower: evt shower: TBP>>=
   procedure :: disable_powheg_matching => evt_shower_disable_powheg_matching
 <<Shower: procedures>>=
   subroutine evt_shower_disable_powheg_matching (evt)
      class(evt_shower_t), intent(inout) :: evt
      select type (matching => evt%matching)
      type is (powheg_matching_t)
         matching%active = .false.
      class default
         call msg_fatal ("Trying to disable powheg but no powheg matching is allocated!")
      end select
   end subroutine evt_shower_disable_powheg_matching
 
 @ %def evt_shower_disable_powheg_matching
 @
 <<Shower: evt shower: TBP>>=
   procedure :: enable_powheg_matching => evt_shower_enable_powheg_matching
 <<Shower: procedures>>=
   subroutine evt_shower_enable_powheg_matching (evt)
      class(evt_shower_t), intent(inout) :: evt
      select type (matching => evt%matching)
      type is (powheg_matching_t)
         matching%active = .true.
      class default
         call msg_fatal ("Trying to enable powheg but no powheg matching is allocated!")
      end select
   end subroutine evt_shower_enable_powheg_matching
 
 @ %def evt_shower_enable_powheg_matching
 @
 <<Shower: evt shower: TBP>>=
   procedure :: final => evt_shower_final
 <<Shower: procedures>>=
   subroutine evt_shower_final (evt)
     class(evt_shower_t), intent(inout) :: evt
     call evt%base_final ()
     if (allocated (evt%matching))  call evt%matching%final ()
   end subroutine evt_shower_final
 
 @ %def evt_shower_final
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[shower_ut.f90]]>>=
 <<File header>>
 
 module shower_ut
   use unit_tests
   use shower_uti
 
 <<Standard module head>>
 
 <<Shower: public test>>
 
 contains
 
 <<Shower: test driver>>
 
 end module shower_ut
 @ %def shower_ut
 @
 <<[[shower_uti.f90]]>>=
 <<File header>>
 
 module shower_uti
 
 <<Use kinds>>
 <<Use strings>>
   use format_utils, only: write_separator
   use os_interface
   use sm_qcd
   use physics_defs, only: BORN
   use model_data
   use state_matrices, only: FM_IGNORE_HELICITY
   use process_libraries
   use rng_base
   use rng_tao
   use mci_base
   use mci_midpoint
   use phs_base
   use phs_single
   use prc_core
   use prc_omega
   use variables
   use models
   use event_transforms
   use tauola_interface !NODEP!
 
   use process, only: process_t
   use instances, only: process_instance_t
 
   use pdf
   use shower_base
   use shower_core
 
   use shower
 
 <<Standard module head>>
 
 <<Shower: test declarations>>
 
 contains
 
 <<Shower: tests>>
 
 end module shower_uti
 
 @ %def shower_uti
 @ API: driver for the unit tests below.
 <<Shower: public test>>=
   public :: shower_test
 <<Shower: test driver>>=
   subroutine shower_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Shower: execute tests>>
   end subroutine shower_test
 
 @ %def shower_test
 @
 \subsubsection{Testbed}
 This sequence sets up a two-jet process, ready for generating events.
 <<Shower: tests>>=
 <<setup testbed>>
 @
 <<setup testbed>>=
   subroutine setup_testbed &
        (prefix, os_data, lib, model_list, process, process_instance)
     type(string_t), intent(in) :: prefix
     type(os_data_t), intent(out) :: os_data
     type(process_library_t), intent(out), target :: lib
     type(model_list_t), intent(out) :: model_list
     class(model_data_t), pointer :: model
     type(model_t), pointer :: model_tmp
     type(process_t), target, intent(out) :: process
     type(process_instance_t), target, intent(out) :: process_instance
     type(var_list_t), pointer :: model_vars
     type(string_t) :: model_name, libname, procname, run_id
     type(process_def_entry_t), pointer :: entry
     type(string_t), dimension(:), allocatable :: prt_in, prt_out
     type(qcd_t) :: qcd
     class(rng_factory_t), allocatable :: rng_factory
     class(prc_core_t), allocatable :: core_template
     class(mci_t), allocatable :: mci_template
     class(phs_config_t), allocatable :: phs_config_template
     real(default) :: sqrts
 
     model_name = "SM"
     libname = prefix // "_lib"
     procname = prefix // "p"
     run_id = "1"
 
     call os_data_init (os_data)
     allocate (rng_tao_factory_t :: rng_factory)
     allocate (model_tmp)
     call model_list%read_model (model_name, model_name // ".mdl", &
          os_data, model_tmp)
     model_vars => model_tmp%get_var_list_ptr ()
     call model_vars%set_real (var_str ("me"), 0._default, &
          is_known = .true.)
     model => model_tmp
 
     call lib%init (libname)
 
     allocate (prt_in (2), source = [var_str ("e-"), var_str ("e+")])
     allocate (prt_out (2), source = [var_str ("d"), var_str ("dbar")])
 
     allocate (entry)
     call entry%init (procname, model, n_in = 2, n_components = 1)
     call omega_make_process_component (entry, 1, &
          model_name, prt_in, prt_out, &
          report_progress=.true.)
     call lib%append (entry)
 
     call lib%configure (os_data)
     call lib%write_makefile (os_data, force = .true., verbose = .false.)
     call lib%clean (os_data, distclean = .false.)
     call lib%write_driver (force = .true.)
     call lib%load (os_data)
 
     call process%init (procname, run_id, lib, os_data, &
          qcd, rng_factory, model)
 
     allocate (prc_omega_t :: core_template)
     allocate (mci_midpoint_t :: mci_template)
     allocate (phs_single_config_t :: phs_config_template)
 
     model => process%get_model_ptr ()
 
     select type (core_template)
     type is (prc_omega_t)
        call core_template%set_parameters (model = model)
     end select
     call process%core_manager_register (BORN, 1, var_str ("omega"))
     call process%allocate_cm_arrays (1)
     call process%allocate_core (1, core_template)
     call process%init_cores ()
     call process%init_component &
        (1, .true., mci_template, phs_config_template)
 
     sqrts = 1000
     call process%setup_beams_sqrts (sqrts, i_core = 1)
     call process%configure_phs ()
     call process%setup_mci ()
     call process%setup_terms ()
 
     call process_instance%init (process)
     call process_instance%integrate (1, 1, 1000)
     call process%final_integration (1)
 
     call process_instance%setup_event_data (i_core = 1)
     call process_instance%init_simulation (1)
     call process_instance%generate_weighted_event (1)
     call process_instance%evaluate_event_data ()
 
   end subroutine setup_testbed
 
 @ %def setup_testbed
 @
 \subsubsection{Trivial Test}
 We generate a two-jet event and shower it using default settings, i.e.
 in disabled mode.
 <<Shower: execute tests>>=
   call test (shower_1, "shower_1", &
        "disabled shower", &
        u, results)
 <<Shower: test declarations>>=
   public :: shower_1
 <<Shower: tests>>=
   subroutine shower_1 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(process_library_t), target :: lib
     type(model_list_t) :: model_list
     class(model_data_t), pointer :: model
     type(model_t), pointer :: model_hadrons
     type(process_t), target :: process
     type(process_instance_t), target :: process_instance
     type(pdf_data_t) :: pdf_data
     integer :: factorization_mode
     logical :: keep_correlations
     class(evt_t), allocatable, target :: evt_trivial
     class(evt_t), allocatable, target :: evt_shower
     type(shower_settings_t) :: settings
     type(taudec_settings_t) :: taudec_settings
 
     write (u, "(A)")  "* Test output: shower_1"
     write (u, "(A)")  "*   Purpose: Two-jet event with disabled shower"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"), &
          os_data, model_hadrons)
     call setup_testbed (var_str ("shower_1"), &
          os_data, lib, model_list, process, process_instance)
 
     write (u, "(A)")  "* Set up trivial transform"
     write (u, "(A)")
 
     allocate (evt_trivial_t :: evt_trivial)
     model => process%get_model_ptr ()
     call evt_trivial%connect (process_instance, model)
     call evt_trivial%prepare_new_event (1, 1)
     call evt_trivial%generate_unweighted ()
 
     factorization_mode = FM_IGNORE_HELICITY
     keep_correlations = .false.
     call evt_trivial%make_particle_set (factorization_mode, keep_correlations)
 
     select type (evt_trivial)
     type is (evt_trivial_t)
        call evt_trivial%write (u)
        call write_separator (u, 2)
     end select
 
     write (u, "(A)")
     write (u, "(A)")  "* Set up shower event transform"
     write (u, "(A)")
 
     allocate (evt_shower_t :: evt_shower)
     select type (evt_shower)
     type is (evt_shower_t)
        call evt_shower%init (model_hadrons, os_data)
        allocate (shower_t :: evt_shower%shower)
        call evt_shower%shower%init (settings, taudec_settings, pdf_data)
        call evt_shower%connect (process_instance, model)
     end select
 
     evt_trivial%next => evt_shower
     evt_shower%previous => evt_trivial
 
     call evt_shower%prepare_new_event (1, 1)
     call evt_shower%generate_unweighted ()
     call evt_shower%make_particle_set (factorization_mode, keep_correlations)
 
     select type (evt_shower)
     type is (evt_shower_t)
        call evt_shower%write (u)
        call write_separator (u, 2)
     end select
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_shower%final ()
     call evt_trivial%final ()
     call process_instance%final ()
     call process%final ()
     call lib%final ()
     call model_hadrons%final ()
     deallocate (model_hadrons)
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: shower_1"
 
   end subroutine shower_1
 
 @ %def shower_1
 @
 \subsubsection{FSR Shower}
 We generate a two-jet event and shower it with the Whizard FSR shower.
 <<Shower: execute tests>>=
   call test (shower_2, "shower_2", &
        "final-state shower", &
        u, results)
 <<Shower: test declarations>>=
   public :: shower_2
 <<Shower: tests>>=
   subroutine shower_2 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     type(process_library_t), target :: lib
     type(model_list_t) :: model_list
     type(model_t), pointer :: model_hadrons
     class(model_data_t), pointer :: model
     type(process_t), target :: process
     type(process_instance_t), target :: process_instance
     integer :: factorization_mode
     logical :: keep_correlations
     type(pdf_data_t) :: pdf_data
     class(evt_t), allocatable, target :: evt_trivial
     class(evt_t), allocatable, target :: evt_shower
     type(shower_settings_t) :: settings
     type(taudec_settings_t) :: taudec_settings
 
     write (u, "(A)")  "* Test output: shower_2"
     write (u, "(A)")  "*   Purpose: Two-jet event with FSR shower"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize environment"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call os_data_init (os_data)
     call model_list%read_model &
          (var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"), &
          os_data, model_hadrons)
     call setup_testbed (var_str ("shower_2"), &
          os_data, lib, model_list, process, process_instance)
     model => process%get_model_ptr ()
 
     write (u, "(A)")  "* Set up trivial transform"
     write (u, "(A)")
 
     allocate (evt_trivial_t :: evt_trivial)
     call evt_trivial%connect (process_instance, model)
     call evt_trivial%prepare_new_event (1, 1)
     call evt_trivial%generate_unweighted ()
 
     factorization_mode = FM_IGNORE_HELICITY
     keep_correlations = .false.
     call evt_trivial%make_particle_set (factorization_mode, keep_correlations)
 
     select type (evt_trivial)
     type is (evt_trivial_t)
        call evt_trivial%write (u)
        call write_separator (u, 2)
     end select
 
     write (u, "(A)")
     write (u, "(A)")  "* Set up shower event transform"
     write (u, "(A)")
 
     settings%fsr_active = .true.
 
     allocate (evt_shower_t :: evt_shower)
     select type (evt_shower)
     type is (evt_shower_t)
        call evt_shower%init (model_hadrons, os_data)
        allocate (shower_t :: evt_shower%shower)
        call evt_shower%shower%init (settings, taudec_settings, pdf_data)
        call evt_shower%connect (process_instance, model)
     end select
 
     evt_trivial%next => evt_shower
     evt_shower%previous => evt_trivial
 
     call evt_shower%prepare_new_event (1, 1)
     call evt_shower%generate_unweighted ()
     call evt_shower%make_particle_set (factorization_mode, keep_correlations)
 
     select type (evt_shower)
     type is (evt_shower_t)
        call evt_shower%write (u, testflag = .true.)
        call write_separator (u, 2)
     end select
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call evt_shower%final ()
     call evt_trivial%final ()
     call process_instance%final ()
     call process%final ()
     call lib%final ()
     call model_hadrons%final ()
     deallocate (model_hadrons)
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: shower_2"
 
   end subroutine shower_2
 
 @ %def shower_2
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Fixed Order NLO Events}
 This section deals with the generation of weighted event samples which
 take into account next-to-leading order corrections. An approach
 generating unweighted events is not possible here, because negative
 weights might occur due to subtraction. Note that the events produced
 this way are not physical in the sense that they will not keep
 NLO-accuracy when interfaced to a parton shower. They are rather
 useful for theoretical consistency checks and a fast estimate of
 NLO effects.\\
 We generate NLO events in the following way: First, the integration
 is carried out using the complete divergence-subtracted NLO matrix
 element. In the subsequent simulation, $N$-particle kinematics
 are generated using $\mathcal{B}+\mathcal{V}+\mathcal{C}$ as weight.
 After that, the program loops over all singular regions and for each
 of them generates an event with $N+1$-particle kinematics.
 The weight for those events corresponds to the real matrix
 element $\mathcal{R}^\alpha$ evaluated at the $\alpha$-region's
 emitter's phase space point, multiplied with $S_\alpha$.
 This procedure is implemented using the [[evt_nlo]] transform.
 
 <<[[evt_nlo.f90]]>>=
 <<File header>>
 
 module evt_nlo
 
 <<Use kinds>>
 <<Use strings>>
   use io_units, only: given_output_unit
   use constants
   use lorentz
   use diagnostics
   use physics_defs, only: NLO_REAL
   use sm_qcd
   use model_data
   use particles
   use instances, only: process_instance_t
   ! TODO (cw-2016-09-16): Ideally, only pcm_base
   use pcm, only: pcm_nlo_t, pcm_instance_nlo_t
   use process_stacks
   use event_transforms
 
   use phs_fks, only: phs_fks_t, phs_fks_generator_t
   use phs_fks, only: phs_identifier_t, phs_point_set_t
   use resonances, only: resonance_contributors_t
   use fks_regions, only: region_data_t
 
 <<Standard module head>>
 
 <<Evt Nlo: public>>
 
 <<Evt Nlo: public parameters>>
 
 <<Evt Nlo: types>>
 
 contains
 
 <<Evt Nlo: procedures>>
 
 end module evt_nlo
 
 @ %def evt_nlo
 @
 <<Evt Nlo: types>>=
   type :: nlo_event_deps_t
      logical :: cm_frame = .true.
      type(phs_point_set_t) :: p_born_cms
      type(phs_point_set_t) :: p_born_lab
      type(phs_point_set_t) :: p_real_cms
      type(phs_point_set_t) :: p_real_lab
      type(resonance_contributors_t), dimension(:), allocatable :: contributors
      type(phs_identifier_t), dimension(:), allocatable :: phs_identifiers
      integer, dimension(:), allocatable :: alr_to_i_con
      integer :: n_phs = 0
   end type nlo_event_deps_t
 
 @ %def nlo_event_deps_t
 @ This event transformation is for the generation of fixed-order NLO events. It
 takes an event with Born kinematics and creates $N_\alpha + 1$ modified weighted events.
 The first one has Born kinematics and its weight is the sum of Born, Real and subtraction
 matrix elements. The other $N_\alpha$ events have a weight which is equal to the real matrix
 element, evaluated with the phase space corresponding to the emitter of the $\alpha$-region.
 All NLO event objects share the same event transformation. For this reason, we save the
 particle set of the current $\alpha$-region in the array [[particle_set_radiated]]. Otherwise
 it would be unretrievable if the usual particle set of the event object was used.@
 <<Evt Nlo: public parameters>>=
   integer, parameter, public :: EVT_NLO_UNDEFINED = 0
   integer, parameter, public :: EVT_NLO_SEPARATE_BORNLIKE = 1
   integer, parameter, public :: EVT_NLO_SEPARATE_REAL = 2
   integer, parameter, public :: EVT_NLO_COMBINED = 3
 <<Evt Nlo: public>>=
   public :: evt_nlo_t
 <<Evt Nlo: types>>=
   type, extends (evt_t) :: evt_nlo_t
     type(phs_fks_generator_t) :: phs_fks_generator
     real(default) :: sqme_rad = zero
     integer :: i_evaluation = 0
     integer :: weight_multiplier = 1
     type(particle_set_t), dimension(:), allocatable :: particle_set_radiated
     type(qcd_t), pointer :: qcd => null ()
     type(nlo_event_deps_t) :: event_deps
     integer :: mode = EVT_NLO_UNDEFINED
     integer, dimension(:), allocatable :: &
        i_evaluation_to_i_phs, i_evaluation_to_emitter, &
        i_evaluation_to_i_term
     logical :: keep_failed_events = .false.
     integer :: selected_i_flv = 0
   contains
   <<Evt Nlo: evt nlo: TBP>>
   end type evt_nlo_t
 
 @ %def evt_nlo_t
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: write_name => evt_nlo_write_name
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_write_name (evt, unit)
     class(evt_nlo_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A)") "Event transform: NLO"
   end subroutine evt_nlo_write_name
 
 @ %def evt_nlo_write_name
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: write => evt_nlo_write
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_write (evt, unit, verbose, more_verbose, testflag)
     class(evt_nlo_t), intent(in) :: evt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose, more_verbose, testflag
   end subroutine evt_nlo_write
 
 @ %def evt_nlo_write
 @ Connects the event transform to the process. Here also the phase space
 is set up by making [[real_kinematics]] point to the corresponding
 object in the [[pcm_instance]].
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: connect => evt_nlo_connect
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_connect (evt, process_instance, model, process_stack)
     class(evt_nlo_t), intent(inout), target :: evt
     type(process_instance_t), intent(in), target :: process_instance
     class(model_data_t), intent(in), target :: model
     type(process_stack_t), intent(in), optional :: process_stack
     call msg_debug (D_TRANSFORMS, "evt_nlo_connect")
     call evt%base_connect (process_instance, model, process_stack)
     select type (pcm => process_instance%pcm)
     class is (pcm_instance_nlo_t)
        select type (config => pcm%config)
        type is (pcm_nlo_t)
           call config%setup_phs_generator (pcm, evt%phs_fks_generator, &
                process_instance%get_sqrts ())
           call evt%set_i_evaluation_mappings (config%region_data, &
                pcm%real_kinematics%alr_to_i_phs)
        end select
     end select
     call evt%set_mode (process_instance)
     call evt%setup_general_event_kinematics (process_instance)
     if (evt%mode > EVT_NLO_SEPARATE_BORNLIKE) &
          call evt%setup_real_event_kinematics (process_instance)
     call msg_debug2 (D_TRANSFORMS, "evt_nlo_connect: success")
   end subroutine evt_nlo_connect
 
 @ %def evt_nlo_connect
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: set_i_evaluation_mappings => evt_nlo_set_i_evaluation_mappings
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_set_i_evaluation_mappings (evt, reg_data, alr_to_i_phs)
     class(evt_nlo_t), intent(inout) :: evt
     type(region_data_t), intent(in) :: reg_data
     integer, intent(in), dimension(:) :: alr_to_i_phs
     integer :: n_phs, alr
     integer :: i_evaluation, i_phs, emitter
     logical :: checked
     type :: registered_triple_t
       integer, dimension(2) :: phs_em
       type(registered_triple_t), pointer :: next => null ()
     end type registered_triple_t
     type(registered_triple_t), allocatable, target :: check_list
     i_evaluation = 1
     n_phs = reg_data%n_phs
     evt%weight_multiplier = n_phs + 1
     allocate (evt%i_evaluation_to_i_phs (n_phs), source = 0)
     allocate (evt%i_evaluation_to_emitter (n_phs), source = -1)
     allocate (evt%i_evaluation_to_i_term (0 : n_phs), source = 0)
     do alr = 1, reg_data%n_regions
        i_phs = alr_to_i_phs (alr)
        emitter = reg_data%regions(alr)%emitter
        call search_check_list (checked)
        if (.not. checked) then
           evt%i_evaluation_to_i_phs (i_evaluation) = i_phs
           evt%i_evaluation_to_emitter (i_evaluation) = emitter
           i_evaluation = i_evaluation + 1
        end if
     end do
     call fill_i_evaluation_to_i_term ()
     if (.not. (all (evt%i_evaluation_to_i_phs > 0) &
        .and. all (evt%i_evaluation_to_emitter > -1))) then
        call msg_fatal ("evt_nlo: Inconsistent mappings!")
     else
        if (debug2_active (D_TRANSFORMS)) then
           print *, 'evt_nlo Mappings, i_evaluation -> '
           print *, 'i_phs: ', evt%i_evaluation_to_i_phs
           print *, 'emitter: ', evt%i_evaluation_to_emitter
        end if
     end if
   contains
     subroutine fill_i_evaluation_to_i_term ()
       integer :: i_term, i_evaluation, term_emitter
       !!! First find subtraction component
       i_evaluation = 1
       do i_term = 1, evt%process%get_n_terms ()
          if (evt%process_instance%term(i_term)%nlo_type /= NLO_REAL) cycle
          term_emitter = evt%process_instance%term(i_term)%k_term%emitter
          if (term_emitter < 0) then
             evt%i_evaluation_to_i_term (0) = i_term
          else if (evt%i_evaluation_to_emitter(i_evaluation) == term_emitter) then
             evt%i_evaluation_to_i_term (i_evaluation) = i_term
             i_evaluation = i_evaluation + 1
          end if
       end do
     end subroutine fill_i_evaluation_to_i_term
 
     subroutine search_check_list (found)
       logical, intent(out) :: found
       type(registered_triple_t), pointer :: current_triple => null ()
       if (allocated (check_list)) then
          current_triple => check_list
          do
             if (all (current_triple%phs_em == [i_phs, emitter])) then
                found = .true.
                exit
             end if
             if (.not. associated (current_triple%next)) then
                allocate (current_triple%next)
                current_triple%next%phs_em = [i_phs, emitter]
                found = .false.
                exit
             else
                current_triple => current_triple%next
             end if
          end do
       else
          allocate (check_list)
          check_list%phs_em = [i_phs, emitter]
          found = .false.
       end if
     end subroutine search_check_list
   end subroutine evt_nlo_set_i_evaluation_mappings
 
 @ %def evt_nlo_set_i_evaluation_mappings
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: get_i_phs => evt_nlo_get_i_phs
 <<Evt Nlo: procedures>>=
   function evt_nlo_get_i_phs (evt) result (i_phs)
     integer :: i_phs
     class(evt_nlo_t), intent(in) :: evt
     i_phs = evt%i_evaluation_to_i_phs (evt%i_evaluation)
   end function evt_nlo_get_i_phs
 
 @ %def evt_nlo_get_i_phs
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: get_emitter => evt_nlo_get_emitter
 <<Evt Nlo: procedures>>=
   function evt_nlo_get_emitter (evt) result (emitter)
     integer :: emitter
     class(evt_nlo_t), intent(in) :: evt
     emitter = evt%i_evaluation_to_emitter (evt%i_evaluation)
   end function evt_nlo_get_emitter
 
 @ %def evt_nlo_get_emitter
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: get_i_term => evt_nlo_get_i_term
 <<Evt Nlo: procedures>>=
   function evt_nlo_get_i_term (evt) result (i_term)
     integer :: i_term
     class(evt_nlo_t), intent(in) :: evt
     if (evt%mode >= EVT_NLO_SEPARATE_REAL) then
        i_term = evt%i_evaluation_to_i_term (evt%i_evaluation)
     else
        i_term = evt%process_instance%get_first_active_i_term ()
     end if
   end function evt_nlo_get_i_term
 
 @ %def evt_nlo_get_i_term
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: copy_previous_particle_set => evt_nlo_copy_previous_particle_set
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_copy_previous_particle_set (evt)
     class(evt_nlo_t), intent(inout) :: evt
     if (associated (evt%previous)) then
        evt%particle_set = evt%previous%particle_set
     else
        call msg_fatal ("evt_nlo requires one preceeding evt_trivial!")
     end if
   end subroutine evt_nlo_copy_previous_particle_set
 
 @ %def evt_nlo_copy_previous_particle_set
 @ The event transform has a variable which counts the number of times it
 has already been called for one generation point. If [[i_evaluation]] is
 zero, this means that [[evt_nlo_generate]] is called for the first time,
 so that the generation of an $N$-particle event is required.  In all
 other cases, emission events are generated.\\
 Note that for the first event, the computed weights are added to
 [[probability]], which at this point is equal to $\mathcal{B} +
 \mathcal{V}$, whereas for all other runs [[probability]] is replaced.
 To keep $<\sum{w_i}>=N\times\sigma$ as it is for weighted LO
 events, we have to multiply by $N_{\rm{phs}} + 1$ since the cross section
 is distributed over the real and Born subevents.
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: generate_weighted => evt_nlo_generate_weighted
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_generate_weighted (evt, probability)
     class(evt_nlo_t), intent(inout) :: evt
     real(default), intent(inout) :: probability
     real(default) :: weight
     call print_debug_info ()
     if (evt%mode > EVT_NLO_SEPARATE_BORNLIKE) then
        if (evt%i_evaluation == 0) then
           call evt%reset_phs_identifiers ()
           call evt%evaluate_real_kinematics ()
           weight = evt%compute_subtraction_weights ()
           if (evt%mode == EVT_NLO_SEPARATE_REAL) then
              probability = weight
           else
              probability = probability + weight
           end if
        else
           call evt%compute_real ()
           probability = evt%sqme_rad
        end if
        call msg_debug2 (D_TRANSFORMS, "event weight multiplier:", evt%weight_multiplier)
        probability = probability * evt%weight_multiplier
     end if
     call msg_debug (D_TRANSFORMS, "probability (after)", probability)
     evt%particle_set_exists = .true.
   contains
     function status_code_to_string (mode) result (smode)
       type(string_t) :: smode
       integer, intent(in) :: mode
       select case (mode)
       case (EVT_NLO_UNDEFINED)
          smode = var_str ("Undefined")
       case (EVT_NLO_SEPARATE_BORNLIKE)
          smode = var_str ("Born-like")
       case (EVT_NLO_SEPARATE_REAL)
          smode = var_str ("Real")
       case (EVT_NLO_COMBINED)
          smode = var_str ("Combined")
       end select
     end function status_code_to_string
 
     subroutine print_debug_info ()
        call msg_debug (D_TRANSFORMS, "evt_nlo_generate_weighted")
        call msg_debug (D_TRANSFORMS, char ("mode: " // status_code_to_string (evt%mode)))
        call msg_debug (D_TRANSFORMS, "probability (before)", probability)
        call msg_debug (D_TRANSFORMS, "evt%i_evaluation", evt%i_evaluation)
        if (debug2_active (D_TRANSFORMS)) then
           if (evt%mode > EVT_NLO_SEPARATE_BORNLIKE) then
              if (evt%i_evaluation == 0) then
                 print *, 'Evaluate subtraction component'
              else
                 print *, 'Evaluate radiation component'
              end if
           end if
        end if
     end subroutine print_debug_info
   end subroutine evt_nlo_generate_weighted
 
 @ %def evt_nlo_generate_weighted
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: reset_phs_identifiers => evt_nlo_reset_phs_identifiers
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_reset_phs_identifiers (evt)
      class(evt_nlo_t), intent(inout) :: evt
      evt%event_deps%phs_identifiers%evaluated = .false.
   end subroutine evt_nlo_reset_phs_identifiers
 
 @ %def evt_nlo_reset_phs_identifiers
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: make_particle_set => evt_nlo_make_particle_set
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_make_particle_set &
        (evt, factorization_mode, keep_correlations, r)
     class(evt_nlo_t), intent(inout) :: evt
     integer, intent(in) :: factorization_mode
     logical, intent(in) :: keep_correlations
     real(default), dimension(:), intent(in), optional :: r
     if (evt%mode >= EVT_NLO_SEPARATE_BORNLIKE) then
        select type (config => evt%process_instance%pcm%config)
        type is (pcm_nlo_t)
           if (evt%i_evaluation > 0) then
              call make_factorized_particle_set (evt, factorization_mode, &
                   keep_correlations, r, evt%get_i_term (), &
                   config%qn_real(:, evt%selected_i_flv))
           else
              call make_factorized_particle_set (evt, factorization_mode, &
                   keep_correlations, r, evt%get_i_term (), &
                   config%qn_born(:, evt%selected_i_flv))
           end if
        end select
     else
        call make_factorized_particle_set (evt, factorization_mode, &
             keep_correlations, r)
     end if
   end subroutine evt_nlo_make_particle_set
 
 @ %def evt_nlo_make_particle_set
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: keep_and_boost_born_particle_set => &
        evt_nlo_keep_and_boost_born_particle_set
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_keep_and_boost_born_particle_set (evt, i_event)
     class(evt_nlo_t), intent(inout) :: evt
     integer, intent(in) :: i_event
     evt%particle_set_radiated(i_event) = evt%particle_set
     if (evt%event_deps%cm_frame) then
        evt%event_deps%p_born_cms%phs_point(1) = &
           evt%particle_set%get_in_and_out_momenta ()
        evt%event_deps%p_born_lab%phs_point(1) = &
           evt%boost_to_lab (evt%event_deps%p_born_cms%phs_point(1))
        call evt%particle_set_radiated(i_event)%replace_incoming_momenta &
           (evt%event_deps%p_born_lab%phs_point(1)%p)
        call evt%particle_set_radiated(i_event)%replace_outgoing_momenta &
           (evt%event_deps%p_born_lab%phs_point(1)%p)
     end if
   end subroutine evt_nlo_keep_and_boost_born_particle_set
 
 @ %def evt_nlo_keep_and_boost_born_particle_set
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: evaluate_real_kinematics => evt_nlo_evaluate_real_kinematics
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_evaluate_real_kinematics (evt)
     class(evt_nlo_t), intent(inout) :: evt
     integer :: alr, i_phs, i_con, emitter
     real(default), dimension(3) :: x_rad
     logical :: use_contributors
     integer :: i_term
 
     select type (pcm => evt%process_instance%pcm)
     class is (pcm_instance_nlo_t)
        x_rad = pcm%real_kinematics%x_rad
        associate (event_deps => evt%event_deps)
           i_term = evt%get_i_term ()
           event_deps%p_born_lab%phs_point(1) = &
                evt%process_instance%term(i_term)%connected%matrix%get_momenta ()
           event_deps%p_born_cms%phs_point(1) &
                = evt%boost_to_cms (event_deps%p_born_lab%phs_point(1))
           call evt%phs_fks_generator%set_sqrts_hat &
                (event_deps%p_born_cms%get_energy (1, 1))
           use_contributors = allocated (event_deps%contributors)
           do alr = 1, pcm%get_n_regions ()
              i_phs = pcm%real_kinematics%alr_to_i_phs(alr)
              if (event_deps%phs_identifiers(i_phs)%evaluated) cycle
              emitter = event_deps%phs_identifiers(i_phs)%emitter
              associate (generator => evt%phs_fks_generator)
                 !!! TODO: (cw-2016-12-30): Replace by n_in
                 if (emitter <= 2) then
                    call generator%prepare_generation (x_rad, i_phs, emitter, &
                         event_deps%p_born_cms%phs_point(1)%p, event_deps%phs_identifiers)
                    call generator%generate_isr (i_phs, &
                         event_deps%p_born_lab%phs_point(1)%p, &
                         event_deps%p_real_lab%phs_point(i_phs)%p)
                    event_deps%p_real_cms%phs_point(i_phs) &
                         = evt%boost_to_cms (event_deps%p_real_lab%phs_point(i_phs))
                 else
                    if (use_contributors) then
                       i_con = event_deps%alr_to_i_con(alr)
                       call generator%prepare_generation (x_rad, i_phs, emitter, &
                            event_deps%p_born_cms%phs_point(1)%p, &
                            event_deps%phs_identifiers, event_deps%contributors, i_con)
                       call generator%generate_fsr (emitter, i_phs, i_con, &
                            event_deps%p_born_cms%phs_point(1)%p, &
                            event_deps%p_real_cms%phs_point(i_phs)%p)
                    else
                       call generator%prepare_generation (x_rad, i_phs, emitter, &
                            event_deps%p_born_cms%phs_point(1)%p, event_deps%phs_identifiers)
                       call generator%generate_fsr (emitter, i_phs, &
                            event_deps%p_born_cms%phs_point(1)%p, &
                            event_deps%p_real_cms%phs_point(i_phs)%p)
                    end if
                    event_deps%p_real_lab%phs_point(i_phs) &
                         = evt%boost_to_lab (event_deps%p_real_cms%phs_point(i_phs))
                 end if
              end associate
              call pcm%set_momenta (event_deps%p_born_lab%phs_point(1)%p, &
                   event_deps%p_real_lab%phs_point(i_phs)%p, i_phs)
              call pcm%set_momenta (event_deps%p_born_cms%phs_point(1)%p, &
                   event_deps%p_real_cms%phs_point(i_phs)%p, i_phs, cms = .true.)
              event_deps%phs_identifiers(i_phs)%evaluated = .true.
           end do
        end associate
     end select
   end subroutine evt_nlo_evaluate_real_kinematics
 
 @ %def evt_nlo_evaluate_real_kinematics
 @ This routine calls the evaluation of the singular regions only for the
 subtraction terms.
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: compute_subtraction_weights => evt_nlo_compute_subtraction_weights
 <<Evt Nlo: procedures>>=
   function evt_nlo_compute_subtraction_weights (evt) result (weight)
     class(evt_nlo_t), intent(inout) :: evt
     real(default) :: weight
     integer :: i_phs, i_term
     call msg_debug (D_TRANSFORMS, "evt_nlo_compute_subtraction_weights")
     weight = zero
     select type (pcm => evt%process_instance%pcm)
     class is (pcm_instance_nlo_t)
        associate (event_deps => evt%event_deps)
           i_phs = 1; i_term = evt%i_evaluation_to_i_term(0)
           call evt%process_instance%compute_sqme_rad (i_term, i_phs, .true.)
           weight = weight + evt%process_instance%get_sqme (i_term)
        end associate
     end select
   end function evt_nlo_compute_subtraction_weights
 
 @ %def evt_nlo_compute_subtraction_weights
 @ This routine calls the evaluation of the singular regions only for
 emission matrix elements.
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: compute_real => evt_nlo_compute_real
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_compute_real (evt)
     class(evt_nlo_t), intent(inout) :: evt
     integer :: i_phs, i_term
     call msg_debug (D_TRANSFORMS, "evt_nlo_compute_real")
     i_phs = evt%get_i_phs ()
     i_term = evt%i_evaluation_to_i_term (evt%i_evaluation)
     select type (pcm => evt%process_instance%pcm)
     class is (pcm_instance_nlo_t)
        associate (event_deps => evt%event_deps)
           call evt%process_instance%compute_sqme_rad (i_term, i_phs, .false.)
           evt%sqme_rad = evt%process_instance%get_sqme (i_term)
        end associate
     end select
   end subroutine evt_nlo_compute_real
 
 @ %def evt_nlo_compute_real
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: boost_to_cms => evt_nlo_boost_to_cms
 <<Evt Nlo: procedures>>=
   function evt_nlo_boost_to_cms (evt, p_lab) result (p_cms)
     type(phs_point_t), intent(in) :: p_lab
     class(evt_nlo_t), intent(in) :: evt
     type(phs_point_t) :: p_cms
     type(lorentz_transformation_t) :: lt_lab_to_cms
     integer :: i_boost
     if (evt%event_deps%cm_frame) then
        lt_lab_to_cms = identity
     else
        if (evt%mode == EVT_NLO_COMBINED) then
           i_boost = 1
        else
           i_boost = evt%process_instance%select_i_term ()
        end if
        lt_lab_to_cms = evt%process_instance%get_boost_to_cms (i_boost)
     end if
     p_cms = lt_lab_to_cms * p_lab
   end function evt_nlo_boost_to_cms
 
 @ %def evt_nlo_boost_to_cms
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: boost_to_lab => evt_nlo_boost_to_lab
 <<Evt Nlo: procedures>>=
   function evt_nlo_boost_to_lab (evt, p_cms) result (p_lab)
     type(phs_point_t) :: p_lab
     class(evt_nlo_t), intent(in) :: evt
     type(phs_point_t), intent(in) :: p_cms
     type(lorentz_transformation_t) :: lt_cms_to_lab
     integer :: i_boost
     if (.not. evt%event_deps%cm_frame) then
        lt_cms_to_lab = identity
     else
        if (evt%mode == EVT_NLO_COMBINED) then
           i_boost = 1
        else
           i_boost = evt%process_instance%select_i_term ()
        end if
        lt_cms_to_lab = evt%process_instance%get_boost_to_lab (i_boost)
     end if
     p_lab = lt_cms_to_lab * p_cms
   end function evt_nlo_boost_to_lab
 
 @ %def evt_nlo_boost_to_lab
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: setup_general_event_kinematics => evt_nlo_setup_general_event_kinematics
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_setup_general_event_kinematics (evt, process_instance)
     class(evt_nlo_t), intent(inout) :: evt
     type(process_instance_t), intent(in) :: process_instance
     integer :: n_born
     associate (event_deps => evt%event_deps)
        event_deps%cm_frame = process_instance%is_cm_frame (1)
        select type (pcm => process_instance%pcm)
        type is (pcm_instance_nlo_t)
           n_born = pcm%get_n_born ()
        end select
        call event_deps%p_born_cms%init (n_born, 1)
        call event_deps%p_born_lab%init (n_born, 1)
     end associate
   end subroutine evt_nlo_setup_general_event_kinematics
 
 @ %def evt_nlo_setup_general_event_kinematics
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: setup_real_event_kinematics => evt_nlo_setup_real_event_kinematics
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_setup_real_event_kinematics (evt, process_instance)
     class(evt_nlo_t), intent(inout) :: evt
     type(process_instance_t), intent(in) :: process_instance
     integer :: n_real, n_phs
     integer :: i_real
     associate (event_deps => evt%event_deps)
        select type (pcm => process_instance%pcm)
        class is (pcm_instance_nlo_t)
           n_real = pcm%get_n_real ()
        end select
        i_real = evt%process%get_first_real_term ()
        select type (phs => process_instance%term(i_real)%k_term%phs)
        type is (phs_fks_t)
           event_deps%phs_identifiers = phs%phs_identifiers
        end select
        n_phs = size (event_deps%phs_identifiers)
        call event_deps%p_real_cms%init (n_real, n_phs)
        call event_deps%p_real_lab%init (n_real, n_phs)
        select type (pcm => process_instance%pcm)
        type is (pcm_instance_nlo_t)
           select type (config => pcm%config)
           type is (pcm_nlo_t)
              if (allocated (config%region_data%alr_contributors)) then
                 allocate (event_deps%contributors (size (config%region_data%alr_contributors)))
                 event_deps%contributors = config%region_data%alr_contributors
              end if
              if (allocated (config%region_data%alr_to_i_contributor)) then
                 allocate (event_deps%alr_to_i_con &
                    (size (config%region_data%alr_to_i_contributor)))
                 event_deps%alr_to_i_con = config%region_data%alr_to_i_contributor
              end if
           end select
        end select
     end associate
   end subroutine evt_nlo_setup_real_event_kinematics
 
 @ %def evt_nlo_setup_real_event_kinematics
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: set_mode => evt_nlo_set_mode
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_set_mode (evt, process_instance)
     class(evt_nlo_t), intent(inout) :: evt
     type(process_instance_t), intent(in) :: process_instance
     integer :: i_real
     select type (pcm => process_instance%pcm)
     type is (pcm_instance_nlo_t)
        select type (config => pcm%config)
        type is (pcm_nlo_t)
           if (config%settings%combined_integration) then
              evt%mode = EVT_NLO_COMBINED
           else
              i_real = evt%process%get_first_real_component ()
              if (i_real == evt%process%extract_active_component_mci ()) then
                 evt%mode = EVT_NLO_SEPARATE_REAL
              else
                 evt%mode = EVT_NLO_SEPARATE_BORNLIKE
              end if
           end if
        end select
     end select
   end subroutine evt_nlo_set_mode
 
 @ %def evt_nlo_set_mode
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: is_valid_event => evt_nlo_is_valid_event
 <<Evt Nlo: procedures>>=
   function evt_nlo_is_valid_event (evt, i_term) result (valid)
     logical :: valid
     class(evt_nlo_t), intent(in) :: evt
     integer, intent(in) :: i_term
     valid = evt%process_instance%term(i_term)%passed
   end function evt_nlo_is_valid_event
 
 @ %def evt_nlo_is_valid_event
 @
 <<Evt Nlo: evt nlo: TBP>>=
   procedure :: prepare_new_event => evt_nlo_prepare_new_event
 <<Evt Nlo: procedures>>=
   subroutine evt_nlo_prepare_new_event (evt, i_mci, i_term)
     class(evt_nlo_t), intent(inout) :: evt
     integer, intent(in) :: i_mci, i_term
     real(default) :: s, x
     real(default) :: sqme_total
     real(default), dimension(:), allocatable :: sqme_flv
     integer :: i
     call evt%reset ()
     if (evt%i_evaluation > 0) return
     call evt%rng%generate (x)
     sqme_total = zero
     allocate (sqme_flv (evt%process_instance%term(1)%config%data%n_flv))
     sqme_flv = zero
     do i = 1, size (evt%process_instance%term)
        associate (term => evt%process_instance%term(i))
           sqme_total = sqme_total + real (sum ( &
                term%connected%matrix%get_matrix_element ()))
           sqme_flv = sqme_flv + real (term%connected%matrix%get_matrix_element ())
        end associate
     end do
     !!! Need absolute values to take into account negative weights
     x = x * abs (sqme_total)
     s = zero
     do i = 1, size (sqme_flv)
        s = s + abs (sqme_flv (i))
        if (s > x) then
           evt%selected_i_flv = i
           exit
        end if
     end do
     if (debug2_active (D_TRANSFORMS)) then
        call msg_print_color ("Selected i_flv: ", COL_GREEN)
        print *, evt%selected_i_flv
     end if
   end subroutine evt_nlo_prepare_new_event
 
 @ %def evt_nlo_prepare_new_event
 @
 \section{Complete Events}
 
 This module combines hard processes with decay chains, shower, and
 hadronization (not implemented yet) to complete events.  It also
 manages the input and output of event records in various formats.
 <<[[events.f90]]>>=
 <<File header>>
 
 module events
 
 <<Use kinds>>
 <<Use strings>>
   use constants, only: one
   use io_units
   use format_utils, only: pac_fmt, write_separator
   use format_defs, only: FMT_12, FMT_19
   use numeric_utils
   use diagnostics
   use variables
   use expr_base
   use model_data
   use state_matrices, only: FM_IGNORE_HELICITY, &
        FM_SELECT_HELICITY, FM_FACTOR_HELICITY, FM_CORRELATED_HELICITY
   use particles
   use subevt_expr
   use rng_base
   use process, only: process_t
   use instances, only: process_instance_t
   use pcm, only: pcm_instance_nlo_t
   use process_stacks
   use event_base
   use event_transforms
   use decays
   use evt_nlo
 
 <<Standard module head>>
 
 <<Events: public>>
 
 <<Events: types>>
 
 <<Events: interfaces>>
 
 contains
 
 <<Events: procedures>>
 
 end module events
 @ %def events
 @
 \subsection{Event configuration}
 The parameters govern the transformation of an event to a particle set.
 
 The [[safety_factor]] reduces the acceptance probability for
 unweighting.  If greater than one, excess events become less likely,
 but the reweighting efficiency also drops.
 
 The [[sigma]] and [[n]] values, if nontrivial, allow for reweighting
 the events according to the requested [[norm_mode]].
 
 Various [[parse_node_t]] objects are taken from the SINDARIN input.
 They encode expressions that apply to the current event.  The
 workspaces for evaluating those expressions are set up in the
 [[event_expr_t]] objects.  Note that these are really pointers,
 so the actual nodes are not stored inside the event object.
 <<Events: types>>=
   type :: event_config_t
      logical :: unweighted = .false.
      integer :: norm_mode = NORM_UNDEFINED
      integer :: factorization_mode = FM_IGNORE_HELICITY
      logical :: keep_correlations = .false.
+     logical :: colorize_subevt = .false.
      real(default) :: sigma = 1
      integer :: n = 1
      real(default) :: safety_factor = 1
      class(expr_factory_t), allocatable :: ef_selection
      class(expr_factory_t), allocatable :: ef_reweight
      class(expr_factory_t), allocatable :: ef_analysis
    contains
    <<Events: event config: TBP>>
   end type event_config_t
 
 @ %def event_config_t
 @ Output.
 <<Events: event config: TBP>>=
   procedure :: write => event_config_write
 <<Events: procedures>>=
   subroutine event_config_write (object, unit, show_expressions)
     class(event_config_t), intent(in) :: object
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: show_expressions
     integer :: u
     u = given_output_unit (unit)
     write (u, "(3x,A,L1)")  "Unweighted         = ", object%unweighted
     write (u, "(3x,A,A)")   "Normalization      = ", &
          char (event_normalization_string (object%norm_mode))
     write (u, "(3x,A)", advance="no")  "Helicity handling  = "
     select case (object%factorization_mode)
     case (FM_IGNORE_HELICITY)
        write (u, "(A)")  "drop"
     case (FM_SELECT_HELICITY)
        write (u, "(A)")  "select"
     case (FM_FACTOR_HELICITY)
        write (u, "(A)")  "factorize"
     end select
     write (u, "(3x,A,L1)")  "Keep correlations  = ", object%keep_correlations
+    if (object%colorize_subevt) then
+       write (u, "(3x,A,L1)")  "Colorize subevent  = ", object%colorize_subevt
+    end if
     if (.not. nearly_equal (object%safety_factor, one)) then
        write (u, "(3x,A," // FMT_12 // ")")  &
             "Safety factor      = ", object%safety_factor
     end if
     if (present (show_expressions)) then
        if (show_expressions) then
           if (allocated (object%ef_selection)) then
              call write_separator (u)
              write (u, "(3x,A)") "Event selection expression:"
              call object%ef_selection%write (u)
           end if
           if (allocated (object%ef_reweight)) then
              call write_separator (u)
              write (u, "(3x,A)") "Event reweighting expression:"
              call object%ef_reweight%write (u)
           end if
           if (allocated (object%ef_analysis)) then
              call write_separator (u)
              write (u, "(3x,A)") "Analysis expression:"
              call object%ef_analysis%write (u)
           end if
        end if
     end if
   end subroutine event_config_write
 
 @ %def event_config_write
 @
 \subsection{The event type}
 This is the concrete implementation of the [[generic_event_t]] core
 that is defined above in the [[event_base]] module.  The core manages
 the main (dressed) particle set pointer and the current values for
 weights and sqme.  The implementation adds configuration data,
 expressions, process references, and event transforms.
 
 Each event refers to a single elementary process.  This process may be
 dressed by a shower, a decay chain etc.  We maintain pointers to a
 process instance.
 
 A list of event transforms (class [[evt_t]]) transform the connected
 interactions of the process instance into the final particle set.  In
 this list, the first transform is always the trivial one, which just
 factorizes the process instance.  Subsequent transforms may apply
 decays, etc.  The [[particle_set]] pointer identifies the particle set
 that we want to be analyzed and returned by the event, usually the
 last one.
 
 Squared matrix element and weight values: when reading events from
 file, the [[ref]] value is the number in the file, while the [[prc]]
 value is the number that we calculate from the momenta in the file,
 possibly with different parameters.  When generating events the first
 time, or if we do not recalculate, the numbers should coincide.
 Furthermore, the array of [[alt]] values is copied from an array of
 alternative event records.  These values should represent calculated
 values.
 
 The [[sqme]] and [[weight]] values mirror corresponding values in the
 [[expr]] subobject.  The idea is that when generating or reading
 events, the event record is filled first, then the [[expr]] object
 acquires copies.  These copies are used for writing events and as targets
 for pointer variables in the analysis expression.
 
 All data that involve user-provided expressions (selection, reweighting,
 analysis) are handled by the [[expr]] subobject.  In particular, evaluating
 the event-selection expression sets the [[passed]] flag.  Furthermore,
 the [[expr]] subobject collects data that can be used in the analysis
 and should be written to file, including copies of [[sqme]] and [[weight]].
 <<Events: public>>=
   public :: event_t
 <<Events: types>>=
   type, extends (generic_event_t) :: event_t
      type(event_config_t) :: config
      type(process_t), pointer :: process => null ()
      type(process_instance_t), pointer :: instance => null ()
      class(rng_t), allocatable :: rng
      integer :: selected_i_mci = 0
      integer :: selected_i_term = 0
      integer :: selected_channel = 0
      logical :: is_complete = .false.
      class(evt_t), pointer :: transform_first => null ()
      class(evt_t), pointer :: transform_last => null ()
      type(event_expr_t) :: expr
      logical :: selection_evaluated = .false.
      logical :: passed = .false.
      real(default), allocatable :: alpha_qcd_forced
      real(default), allocatable :: scale_forced
      real(default) :: reweight = 1
      logical :: analysis_flag = .false.
      integer :: i_event = 0
    contains
    <<Events: event: TBP>>
   end type event_t
 
 @ %def event_t
 @
 <<Events: event: TBP>>=
   procedure :: clone => event_clone
 <<Events: procedures>>=
   subroutine event_clone (event, event_new)
     class(event_t), intent(in), target :: event
     class(event_t), intent(out), target:: event_new
     type(string_t) :: id
     integer :: num_id
     event_new%config = event%config
     event_new%process => event%process
     event_new%instance => event%instance
     if (allocated (event%rng)) &
          allocate(event_new%rng, source=event%rng)
     event_new%selected_i_mci = event%selected_i_mci
     event_new%selected_i_term = event%selected_i_term
     event_new%selected_channel = event%selected_channel
     event_new%is_complete = event%is_complete
     event_new%transform_first => event%transform_first
     event_new%transform_last => event%transform_last
     event_new%selection_evaluated = event%selection_evaluated
     event_new%passed = event%passed
     if (allocated (event%alpha_qcd_forced)) &
          allocate(event_new%alpha_qcd_forced, source=event%alpha_qcd_forced)
     if (allocated (event%scale_forced)) &
          allocate(event_new%scale_forced, source=event%scale_forced)
     event_new%reweight = event%reweight
     event_new%analysis_flag = event%analysis_flag
     event_new%i_event = event%i_event
     id = event_new%process%get_id ()
     if (id /= "")  call event_new%expr%set_process_id (id)
     num_id = event_new%process%get_num_id ()
     if (num_id /= 0)  call event_new%expr%set_process_num_id (num_id)
     call event_new%expr%setup_vars (event_new%process%get_sqrts ())
     call event_new%expr%link_var_list (event_new%process%get_var_list_ptr ())
   end subroutine event_clone
 
 @ %def event_clone
 @ Finalizer: the list of event transforms is deleted iteratively.
 <<Events: event: TBP>>=
   procedure :: final => event_final
 <<Events: procedures>>=
   subroutine event_final (object)
     class(event_t), intent(inout) :: object
     class(evt_t), pointer :: evt
     if (allocated (object%rng))  call object%rng%final ()
     call object%expr%final ()
     do while (associated (object%transform_first))
        evt => object%transform_first
        object%transform_first => evt%next
        call evt%final ()
        deallocate (evt)
     end do
   end subroutine event_final
 
 @ %def event_final
 @ Output.
 
 The event index is written in the header, it should coincide with the
 [[event_index]] variable that can be used in selection and analysis.
 
 Particle set: this is a pointer to one of the event transforms, so it
 should suffice to print the latter.
 <<Events: event: TBP>>=
   procedure :: write => event_write
 <<Events: procedures>>=
   subroutine event_write (object, unit, show_process, show_transforms, &
        show_decay, verbose, testflag)
     class(event_t), intent(in) :: object
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: show_process, show_transforms, show_decay
     logical, intent(in), optional :: verbose
     logical, intent(in), optional :: testflag
     logical :: prc, trans, dec, verb
     class(evt_t), pointer :: evt
     character(len=7) :: fmt
     integer :: u, i
     call pac_fmt (fmt, FMT_19, FMT_12, testflag)
     u = given_output_unit (unit)
     prc = .true.;  if (present (show_process))  prc = show_process
     trans = .true.;  if (present (show_transforms))  trans = show_transforms
     dec = .true.;  if (present (show_decay))  dec = show_decay
     verb = .false.;  if (present (verbose))  verb = verbose
     call write_separator (u, 2)
     write (u, "(1x,A)", advance="no")  "Event"
     if (object%has_index ()) then
        write (u, "(1x,'#',I0)", advance="no")  object%get_index ()
     end if
     if (object%is_complete) then
        write (u, *)
     else
        write (u, "(1x,A)")  "[incomplete]"
     end if
     call write_separator (u)
     call object%config%write (u)
     if (object%sqme_ref_is_known () .or. object%weight_ref_is_known ()) then
        call write_separator (u)
     end if
     if (object%sqme_ref_is_known ()) then
        write (u, "(3x,A," // fmt // ")") &
             "Squared matrix el. (ref) = ", object%get_sqme_ref ()
        if (object%sqme_alt_is_known ()) then
           do i = 1, object%get_n_alt ()
              write (u, "(5x,A," // fmt // ",1x,I0)")  &
                   "alternate sqme   = ", object%get_sqme_alt(i), i
           end do
        end if
     end if
     if (object%sqme_prc_is_known ()) &
        write (u, "(3x,A," // fmt // ")") &
             "Squared matrix el. (prc) = ", object%get_sqme_prc ()
 
     if (object%weight_ref_is_known ()) then
        write (u, "(3x,A," // fmt // ")") &
             "Event weight (ref)       = ", object%get_weight_ref ()
        if (object%weight_alt_is_known ()) then
           do i = 1, object%get_n_alt ()
              write (u, "(5x,A," // fmt // ",1x,I0)")  &
                   "alternate weight      = ", object%get_weight_alt(i), i
           end do
        end if
     end if
     if (object%weight_prc_is_known ()) &
        write (u, "(3x,A," // fmt // ")") &
             "Event weight (prc)       = ", object%get_weight_prc ()
 
     if (object%selected_i_mci /= 0) then
        call write_separator (u)
        write (u, "(3x,A,I0)")  "Selected MCI group = ", object%selected_i_mci
        write (u, "(3x,A,I0)")  "Selected term      = ", object%selected_i_term
        write (u, "(3x,A,I0)")  "Selected channel   = ", object%selected_channel
     end if
     if (object%selection_evaluated) then
        call write_separator (u)
        write (u, "(3x,A,L1)")  "Passed selection   = ", object%passed
        if (object%passed) then
           write (u, "(3x,A," // fmt // ")") &
                "Reweighting factor = ", object%reweight
           write (u, "(3x,A,L1)") &
                "Analysis flag      = ", object%analysis_flag
        end if
     end if
     if (associated (object%instance)) then
        if (prc) then
           if (verb) then
              call object%instance%write (u, testflag)
           else
              call object%instance%write_header (u)
           end if
        end if
        if (trans) then
           evt => object%transform_first
           do while (associated (evt))
              select type (evt)
              type is (evt_decay_t)
                 call evt%write (u, verbose = dec, more_verbose = verb, &
                      testflag = testflag)
              class default
                 call evt%write (u, verbose = verb, testflag = testflag)
              end select
              call write_separator (u, 2)
              evt => evt%next
           end do
        else
           call write_separator (u, 2)
        end if
        if (object%expr%subevt_filled) then
           call object%expr%write (u, pacified = testflag)
           call write_separator (u, 2)
        end if
     else
        call write_separator (u, 2)
        write (u, "(1x,A)")  "Process instance: [undefined]"
        call write_separator (u, 2)
     end if
   end subroutine event_write
 
 @ %def event_write
 @
 \subsection{Initialization}
 Initialize: set configuration parameters, using a variable list.  We
 do not call this [[init]], because this method name will be used by a type
 extension.
 
 The default normalization is [[NORM_SIGMA]], since the default
 generation mode is weighted.
 
 For unweighted events, we may want to a apply a safety factor to event
 rejection.  (By default, this factor is unity and can be ignored.)
 
 We also allocate the trivial event transform, which is always the
 first one.
 <<Events: event: TBP>>=
   procedure :: basic_init => event_init
 <<Events: procedures>>=
   subroutine event_init (event, var_list, n_alt)
     class(event_t), intent(out) :: event
     type(var_list_t), intent(in), optional :: var_list
     integer, intent(in), optional :: n_alt
     type(string_t) :: norm_string, mode_string
     logical :: polarized_events
     if (present (n_alt)) then
        call event%base_init (n_alt)
        call event%expr%init (n_alt)
     else
        call event%base_init (0)
     end if
     if (present (var_list)) then
        event%config%unweighted = var_list%get_lval (&
             var_str ("?unweighted"))
        norm_string = var_list%get_sval (&
             var_str ("$sample_normalization"))
        event%config%norm_mode = &
             event_normalization_mode (norm_string, event%config%unweighted)
        polarized_events = &
             var_list%get_lval (var_str ("?polarized_events"))
        if (polarized_events) then
           mode_string = &
                var_list%get_sval (var_str ("$polarization_mode"))
           select case (char (mode_string))
           case ("ignore")
              event%config%factorization_mode = FM_IGNORE_HELICITY
           case ("helicity")
              event%config%factorization_mode = FM_SELECT_HELICITY
           case ("factorized")
              event%config%factorization_mode = FM_FACTOR_HELICITY
           case ("correlated")
              event%config%factorization_mode = FM_CORRELATED_HELICITY
           case default
              call msg_fatal ("Polarization mode " &
                   // char (mode_string) // " is undefined")
           end select
        else
           event%config%factorization_mode = FM_IGNORE_HELICITY
        end if
+       event%config%colorize_subevt = &
+            var_list%get_lval (var_str ("?colorize_subevt"))
        if (event%config%unweighted) then
           event%config%safety_factor = var_list%get_rval (&
                var_str ("safety_factor"))
        end if
     else
        event%config%norm_mode = NORM_SIGMA
     end if
     allocate (evt_trivial_t :: event%transform_first)
     event%transform_last => event%transform_first
   end subroutine event_init
 
 @ %def event_init
 @ Set the [[sigma]] and [[n]] values in the configuration record that
 determine non-standard event normalizations.  If these numbers are not
 set explicitly, the default value for both is unity, and event
 renormalization has no effect.
 <<Events: event: TBP>>=
   procedure :: set_sigma => event_set_sigma
   procedure :: set_n => event_set_n
 <<Events: procedures>>=
   elemental subroutine event_set_sigma (event, sigma)
     class(event_t), intent(inout) :: event
     real(default), intent(in) :: sigma
     event%config%sigma = sigma
   end subroutine event_set_sigma
 
   elemental subroutine event_set_n (event, n)
     class(event_t), intent(inout) :: event
     integer, intent(in) :: n
     event%config%n = n
   end subroutine event_set_n
 
 @ %def event_set_n
 @ Append an event transform (decays, etc.).  The transform is not yet
 connected to a process.  The transform is then considered to belong to
 the event object, and will be finalized together with it.  The
 original pointer is removed.
 
 We can assume that the trivial transform is already present in the
 event object, at least.
 <<Events: event: TBP>>=
   procedure :: import_transform => event_import_transform
 <<Events: procedures>>=
   subroutine event_import_transform (event, evt)
     class(event_t), intent(inout) :: event
     class(evt_t), intent(inout), pointer :: evt
     event%transform_last%next => evt
     evt%previous => event%transform_last
     event%transform_last => evt
     evt => null ()
   end subroutine event_import_transform
 
 @ %def event_import_transform
 @
 We link the event to an existing process instance.  This
 includes the variable list, which is linked to the process variable
 list.  Note that this is not necessarily identical to the variable
 list used for event initialization.
 
 The variable list will contain pointers to [[event]] subobjects, therefore the
 [[target]] attribute.
 
 Once we have a process connected, we can use it to obtain an event
 generator instance.
 
 The model and process stack may be needed by event transforms.  The
 current model setting may be different from the model in the process
 (regarding unstable particles, etc.).  The process stack can be used
 for assigning extra processes that we need for the event transforms.
 <<Events: event: TBP>>=
   procedure :: connect => event_connect
 <<Events: procedures>>=
   subroutine event_connect (event, process_instance, model, process_stack)
     class(event_t), intent(inout), target :: event
     type(process_instance_t), intent(in), target :: process_instance
     class(model_data_t), intent(in), target :: model
     type(process_stack_t), intent(in), optional :: process_stack
     type(string_t) :: id
     integer :: num_id
     class(evt_t), pointer :: evt
     event%process => process_instance%process
     event%instance => process_instance
     id = event%process%get_id ()
     if (id /= "")  call event%expr%set_process_id (id)
     num_id = event%process%get_num_id ()
     if (num_id /= 0)  call event%expr%set_process_num_id (num_id)
     call event%expr%setup_vars (event%process%get_sqrts ())
     call event%expr%link_var_list (event%process%get_var_list_ptr ())
     call event%process%make_rng (event%rng)
     evt => event%transform_first
     do while (associated (evt))
        call evt%connect (process_instance, model, process_stack)
        evt => evt%next
     end do
   end subroutine event_connect
 
 @ %def event_connect
 @ Set the parse nodes for the associated expressions, individually.  The
 parse-node pointers may be null.
 <<Events: event: TBP>>=
   procedure :: set_selection => event_set_selection
   procedure :: set_reweight => event_set_reweight
   procedure :: set_analysis => event_set_analysis
 <<Events: procedures>>=
   subroutine event_set_selection (event, ef_selection)
     class(event_t), intent(inout) :: event
     class(expr_factory_t), intent(in) :: ef_selection
     allocate (event%config%ef_selection, source = ef_selection)
   end subroutine event_set_selection
 
   subroutine event_set_reweight (event, ef_reweight)
     class(event_t), intent(inout) :: event
     class(expr_factory_t), intent(in) :: ef_reweight
     allocate (event%config%ef_reweight, source = ef_reweight)
   end subroutine event_set_reweight
 
   subroutine event_set_analysis (event, ef_analysis)
     class(event_t), intent(inout) :: event
     class(expr_factory_t), intent(in) :: ef_analysis
     allocate (event%config%ef_analysis, source = ef_analysis)
   end subroutine event_set_analysis
 
 @ %def event_set_selection
 @ %def event_set_reweight
 @ %def event_set_analysis
 @ Create evaluation trees from the parse trees.  The [[target]] attribute is
 required because the expressions contain pointers to event subobjects.
 <<Events: event: TBP>>=
   procedure :: setup_expressions => event_setup_expressions
 <<Events: procedures>>=
   subroutine event_setup_expressions (event)
     class(event_t), intent(inout), target :: event
     call event%expr%setup_selection (event%config%ef_selection)
     call event%expr%setup_analysis (event%config%ef_analysis)
     call event%expr%setup_reweight (event%config%ef_reweight)
+    call event%expr%colorize (event%config%colorize_subevt)
   end subroutine event_setup_expressions
 
 @ %def event_setup_expressions
 @
 \subsection{Evaluation}
 To fill the [[particle_set]], i.e., the event record proper, we have
 to apply all event transforms in order.  The last transform should
 fill its associated particle set, factorizing the state matrix
 according to the current settings.  There are several parameters
 in the event configuration that control this.
 
 We always fill the particle set for the first transform (the hard
 process) and the last transform, if different from the first (the
 fully dressed process).
 
 Each event transform is an event generator of its own.  We choose to
 generate an \emph{unweighted} event for each of them, even if the master
 event is assumed to be weighted.  Thus, the overall event weight is
 the one of the hard process only.  (There may be more options in future
 extensions.)
 
 We can generate the two random numbers that the factorization needs.
 For testing purpose, we allow for providing them explicitly, as an option.
 <<Events: event: TBP>>=
   procedure :: evaluate_transforms => event_evaluate_transforms
 <<Events: procedures>>=
   subroutine event_evaluate_transforms (event, r)
     class(event_t), intent(inout) :: event
     real(default), dimension(:), intent(in), optional :: r
     class(evt_t), pointer :: evt
     real(default) :: sigma_over_sqme
     integer :: i_term
     logical :: failed_but_keep
     failed_but_keep = .false.
     call msg_debug (D_TRANSFORMS, "event_evaluate_transforms")
     call event%discard_particle_set ()
     call event%check ()
     if (event%instance%is_complete_event ()) then
        i_term = event%instance%select_i_term ()
        event%selected_i_term = i_term
        evt => event%transform_first
        do while (associated (evt))
           call evt%prepare_new_event &
                (event%selected_i_mci, event%selected_i_term)
           evt => evt%next
        end do
        evt => event%transform_first
        call msg_debug (D_TRANSFORMS, "Before event transformations")
        call msg_debug (D_TRANSFORMS, "event%weight_prc", event%weight_prc)
        call msg_debug (D_TRANSFORMS, "event%sqme_prc", event%sqme_prc)
        do while (associated (evt))
           call print_transform_name_if_debug ()
           if (evt%only_weighted_events) then
              select type (evt)
              type is (evt_nlo_t)
                 failed_but_keep = .not. evt%is_valid_event (i_term) .and. evt%keep_failed_events
                 if (.not. evt%is_valid_event (i_term) .and. .not. failed_but_keep) &
                    return
              end select
              if (abs (event%weight_prc) > 0._default) then
                 sigma_over_sqme = event%weight_prc / event%sqme_prc
                 call evt%generate_weighted (event%sqme_prc)
                 event%weight_prc = sigma_over_sqme * event%sqme_prc
              else
                 if (.not. failed_but_keep) exit
              end if
           else
              call evt%generate_unweighted ()
           end if
           if (signal_is_pending ())  return
           call evt%make_particle_set (event%config%factorization_mode, &
                event%config%keep_correlations)
           if (signal_is_pending ())  return
           if (.not. evt%particle_set_exists) exit
           evt => evt%next
        end do
        evt => event%transform_last
        if ((associated (evt) .and. evt%particle_set_exists) .or. failed_but_keep) then
           if (event%is_nlo ()) then
              select type (evt)
              type is (evt_nlo_t)
                 if (evt%i_evaluation > 0) then
                    evt%particle_set_radiated (event%i_event + 1) = evt%particle_set
                 else
                    call evt%keep_and_boost_born_particle_set (event%i_event + 1)
                 end if
                 evt%i_evaluation = evt%i_evaluation + 1
                 call event%link_particle_set &
                    (evt%particle_set_radiated(event%i_event + 1))
              end select
           else
              call event%link_particle_set (evt%particle_set)
           end if
        end if
        call msg_debug (D_TRANSFORMS, "After event transformations")
        call msg_debug (D_TRANSFORMS, "event%weight_prc", event%weight_prc)
        call msg_debug (D_TRANSFORMS, "event%sqme_prc", event%sqme_prc)
        call msg_debug (D_TRANSFORMS, "evt%particle_set_exists", evt%particle_set_exists)
     end if
   contains
     subroutine print_transform_name_if_debug ()
        if (debug_active (D_TRANSFORMS)) then
           print *, 'Current event transform: '
           call evt%write_name ()
        end if
     end subroutine print_transform_name_if_debug
   end subroutine event_evaluate_transforms
 
 @ %def event_evaluate_transforms
 @ Set / increment the event index for the current event.  There is no
 condition for this to happen.  The event index is actually stored in
 the subevent expression, because this allows us to access it in
 subevent expressions as a variable.
 <<Events: event: TBP>>=
   procedure :: set_index => event_set_index
   procedure :: increment_index => event_increment_index
 <<Events: procedures>>=
   subroutine event_set_index (event, index)
     class(event_t), intent(inout) :: event
     integer, intent(in) :: index
     call event%expr%set_event_index (index)
   end subroutine event_set_index
   
   subroutine event_increment_index (event, offset)
     class(event_t), intent(inout) :: event
     integer, intent(in), optional :: offset
     call event%expr%increment_event_index (offset)
   end subroutine event_increment_index
   
 @ %def event_set_index
 @ %def event_increment_index
 @
 Evaluate the event-related expressions, given a valid
 [[particle_set]].  If [[update_sqme]] is set, we use the process
 instance for the [[sqme_prc]] value.  The [[sqme_ref]] value is
 always taken from the event record.
 
 Note: without the explicit [[particle_set]] pointer, some gfortran 4.8
 version corrupts its memory.
 <<Events: event: TBP>>=
   procedure :: evaluate_expressions => event_evaluate_expressions
 <<Events: procedures>>=
   subroutine event_evaluate_expressions (event)
     class(event_t), intent(inout) :: event
     type(particle_set_t), pointer :: particle_set
     if (event%has_valid_particle_set ()) then
        particle_set => event%get_particle_set_ptr ()
        call event%expr%fill_subevt (particle_set)
     end if
     if (event%weight_ref_is_known ()) then
        call event%expr%set (weight_ref = event%get_weight_ref ())
     end if
     if (event%weight_prc_is_known ()) then
        call event%expr%set (weight_prc = event%get_weight_prc ())
     end if
     if (event%excess_prc_is_known ()) then
        call event%expr%set (excess_prc = event%get_excess_prc ())
     end if
     if (event%sqme_ref_is_known ()) then
        call event%expr%set (sqme_ref = event%get_sqme_ref ())
     end if
     if (event%sqme_prc_is_known ()) then
        call event%expr%set (sqme_prc = event%get_sqme_prc ())
     end if
     if (event%has_valid_particle_set ()) then
        call event%expr%evaluate &
             (event%passed, event%reweight, event%analysis_flag)
        event%selection_evaluated = .true.
     end if
   end subroutine event_evaluate_expressions
 
 @ %def event_evaluate_expressions
 @ Report the result of the [[selection]] evaluation.
 <<Events: event: TBP>>=
   procedure :: passed_selection => event_passed_selection
 <<Events: procedures>>=
   function event_passed_selection (event) result (flag)
     class(event_t), intent(in) :: event
     logical :: flag
     flag = event%passed
   end function event_passed_selection
 
 @ %def event_passed_selection
 @ Set alternate sqme and weight arrays.  This should be merged with
 the previous routine, if the expressions are allowed to refer to these
 values.
 <<Events: event: TBP>>=
   procedure :: store_alt_values => event_store_alt_values
 <<Events: procedures>>=
   subroutine event_store_alt_values (event)
     class(event_t), intent(inout) :: event
     if (event%weight_alt_is_known ()) then
        call event%expr%set (weight_alt = event%get_weight_alt ())
     end if
     if (event%sqme_alt_is_known ()) then
        call event%expr%set (sqme_alt = event%get_sqme_alt ())
     end if
   end subroutine event_store_alt_values
 
 @ %def event_store_alt_values
 @
 <<Events: event: TBP>>=
   procedure :: is_nlo => event_is_nlo
 <<Events: procedures>>=
   function event_is_nlo (event) result (is_nlo)
     logical :: is_nlo
     class(event_t), intent(in) :: event
     if (associated (event%instance)) then
        select type (pcm => event%instance%pcm)
        type is (pcm_instance_nlo_t)
           is_nlo = pcm%is_fixed_order_nlo_events ()
        class default
           is_nlo = .false.
        end select
     else
        is_nlo = .false.
     end if
   end function event_is_nlo
 
 @ %def event_is_nlo
 @
 \subsection{Reset to empty state}
 Applying this, current event contents are marked as incomplete but
 are not deleted.  In particular, the initialization is kept.  The
 event index is also kept, this can be reset separately.
 <<Events: event: TBP>>=
   procedure :: reset_contents => event_reset_contents
   procedure :: reset_index => event_reset_index
 <<Events: procedures>>=
   subroutine event_reset_contents (event)
     class(event_t), intent(inout) :: event
     class(evt_t), pointer :: evt
     call event%base_reset_contents ()
     event%selected_i_mci = 0
     event%selected_i_term = 0
     event%selected_channel = 0
     event%is_complete = .false.
     call event%expr%reset_contents ()
     event%selection_evaluated = .false.
     event%passed = .false.
     event%analysis_flag = .false.
     if (associated (event%instance)) then
        call event%instance%reset (reset_mci = .true.)
     end if
     if (allocated (event%alpha_qcd_forced))  deallocate (event%alpha_qcd_forced)
     if (allocated (event%scale_forced))  deallocate (event%scale_forced)
     evt => event%transform_first
     do while (associated (evt))
        call evt%reset ()
        evt => evt%next
     end do
   end subroutine event_reset_contents
 
   subroutine event_reset_index (event)
     class(event_t), intent(inout) :: event
     call event%expr%reset_event_index ()
   end subroutine event_reset_index
 
 @ %def event_reset_contents
 @ %def event_reset_index
 @
 \subsection{Squared Matrix Element and Weight}
 Transfer the result of the process instance calculation to the
 event record header.
 <<Events: event: TBP>>=
   procedure :: import_instance_results => event_import_instance_results
 <<Events: procedures>>=
   subroutine event_import_instance_results (event)
     class(event_t), intent(inout) :: event
     if (associated (event%instance)) then
        if (event%instance%has_evaluated_trace ()) then
           call event%set ( &
                sqme_prc = event%instance%get_sqme (), &
                weight_prc = event%instance%get_weight (), &
                excess_prc = event%instance%get_excess () &
                )
        end if
     end if
   end subroutine event_import_instance_results
 
 @ %def event_import_instance_results
 @ Duplicate the instance result / the reference result in the event
 record.
 <<Events: event: TBP>>=
   procedure :: accept_sqme_ref => event_accept_sqme_ref
   procedure :: accept_sqme_prc => event_accept_sqme_prc
   procedure :: accept_weight_ref => event_accept_weight_ref
   procedure :: accept_weight_prc => event_accept_weight_prc
 <<Events: procedures>>=
   subroutine event_accept_sqme_ref (event)
     class(event_t), intent(inout) :: event
     if (event%sqme_ref_is_known ()) then
        call event%set (sqme_prc = event%get_sqme_ref ())
     end if
   end subroutine event_accept_sqme_ref
 
   subroutine event_accept_sqme_prc (event)
     class(event_t), intent(inout) :: event
     if (event%sqme_prc_is_known ()) then
        call event%set (sqme_ref = event%get_sqme_prc ())
     end if
   end subroutine event_accept_sqme_prc
 
   subroutine event_accept_weight_ref (event)
     class(event_t), intent(inout) :: event
     if (event%weight_ref_is_known ()) then
        call event%set (weight_prc = event%get_weight_ref ())
     end if
   end subroutine event_accept_weight_ref
 
   subroutine event_accept_weight_prc (event)
     class(event_t), intent(inout) :: event
     if (event%weight_prc_is_known ()) then
        call event%set (weight_ref = event%get_weight_prc ())
     end if
   end subroutine event_accept_weight_prc
 
 @ %def event_accept_sqme_ref
 @ %def event_accept_sqme_prc
 @ %def event_accept_weight_ref
 @ %def event_accept_weight_prc
 @ Update the weight normalization, just after generation.  Unweighted
 and weighted events are generated with a different default
 normalization.  The intended normalization is stored in the
 configuration record.
 <<Events: event: TBP>>=
   procedure :: update_normalization => event_update_normalization
 <<Events: procedures>>=
   subroutine event_update_normalization (event, mode_ref)
     class(event_t), intent(inout) :: event
     integer, intent(in), optional :: mode_ref
     integer :: mode_old
     real(default) :: weight, excess
     if (present (mode_ref)) then
        mode_old = mode_ref
     else if (event%config%unweighted) then
        mode_old = NORM_UNIT
     else
        mode_old = NORM_SIGMA
     end if
     weight = event%get_weight_prc ()
     call event_normalization_update (weight, &
          event%config%sigma, event%config%n, &
          mode_new = event%config%norm_mode, &
          mode_old = mode_old)
     call event%set_weight_prc (weight)
     excess = event%get_excess_prc ()
     call event_normalization_update (excess, &
          event%config%sigma, event%config%n, &
          mode_new = event%config%norm_mode, &
          mode_old = mode_old)
     call event%set_excess_prc (excess)
   end subroutine event_update_normalization
 
 @ %def event_update_normalization
 @
 The event is complete if it has a particle set plus valid entries for
 the sqme and weight values.
 <<Events: event: TBP>>=
   procedure :: check => event_check
 <<Events: procedures>>=
   subroutine event_check (event)
     class(event_t), intent(inout) :: event
     event%is_complete = event%has_valid_particle_set () &
          .and. event%sqme_ref_is_known () &
          .and. event%sqme_prc_is_known () &
          .and. event%weight_ref_is_known () &
          .and. event%weight_prc_is_known ()
     if (event%get_n_alt () /= 0) then
        event%is_complete = event%is_complete &
             .and. event%sqme_alt_is_known () &
             .and. event%weight_alt_is_known ()
     end if
   end subroutine event_check
 
 @ %def event_check
 @
 @
 \subsection{Generation}
 Assuming that we have a valid process associated to the event, we
 generate an event.  We complete the event data, then factorize the
 spin density matrix and transfer it to the particle set.
 
 When done, we retrieve squared matrix element and weight.  In case of
 explicit generation, the reference values coincide with the process
 values, so we [[accept]] the latter.
 
 The explicit random number argument [[r]] should be generated by a
 random-number generator.  It is taken for the factorization algorithm,
 bypassing the event-specific random-number generator.  This is useful
 for deterministic testing.
 <<Events: event: TBP>>=
   procedure :: generate => event_generate
 <<Events: procedures>>=
   subroutine event_generate (event, i_mci, r, i_nlo)
     class(event_t), intent(inout) :: event
     integer, intent(in) :: i_mci
     real(default), dimension(:), intent(in), optional :: r
     integer, intent(in), optional :: i_nlo
     logical :: generate_new
     generate_new = .true.
     if (present (i_nlo)) generate_new = (i_nlo == 1)
     if (generate_new) call event%reset_contents ()
     event%selected_i_mci = i_mci
     if (event%config%unweighted) then
        call event%instance%generate_unweighted_event (i_mci)
        if (signal_is_pending ()) return
        call event%instance%evaluate_event_data ()
        call event%instance%normalize_weight ()
     else
        if (generate_new) &
           call event%instance%generate_weighted_event (i_mci)
        if (signal_is_pending ()) return
        call event%instance%evaluate_event_data ()
     end if
     event%selected_channel = event%instance%get_channel ()
     call event%import_instance_results ()
     call event%accept_sqme_prc ()
     call event%update_normalization ()
     call event%accept_weight_prc ()
     call event%evaluate_transforms (r)
     if (signal_is_pending ())  return
     call event%check ()
   end subroutine event_generate
 
 @ %def event_generate
 @ Get a copy of the particle set belonging to the hard process.
 <<Events: event: TBP>>=
   procedure :: get_hard_particle_set => event_get_hard_particle_set
 <<Events: procedures>>=
   subroutine event_get_hard_particle_set (event, pset)
     class(event_t), intent(in) :: event
     type(particle_set_t), intent(out) :: pset
     class(evt_t), pointer :: evt
     evt => event%transform_first
     pset = evt%particle_set
   end subroutine event_get_hard_particle_set
 
 @ %def event_get_hard_particle_set
 @
 \subsection{Recovering an event}
 Select MC group, term, and integration channel.
 <<Events: event: TBP>>=
   procedure :: select => event_select
 <<Events: procedures>>=
   subroutine event_select (event, i_mci, i_term, channel)
     class(event_t), intent(inout) :: event
     integer, intent(in) :: i_mci, i_term, channel
     if (associated (event%instance)) then
        event%selected_i_mci = i_mci
        event%selected_i_term = i_term
        event%selected_channel = channel
     else
        event%selected_i_mci = 0
        event%selected_i_term = 0
        event%selected_channel = 0
     end if
   end subroutine event_select
 
 @ %def event_select
 @
 Copy a particle set into the event record.
 
 We deliberately use the first (the trivial) transform for this, i.e.,
 the hard process.  The event reader may either read in the transformed
 event separately, or apply all event
 transforms to the hard particle set to (re)generate a fully dressed
 event.
 
 Since this makes all subsequent event transforms invalid, we call
 [[reset]] on them.
 <<Events: event: TBP>>=
   procedure :: set_hard_particle_set => event_set_hard_particle_set
 <<Events: procedures>>=
   subroutine event_set_hard_particle_set (event, particle_set)
     class(event_t), intent(inout) :: event
     type(particle_set_t), intent(in) :: particle_set
     class(evt_t), pointer :: evt
     evt => event%transform_first
     call evt%set_particle_set (particle_set, &
          event%selected_i_mci, event%selected_i_term)
     call event%link_particle_set (evt%particle_set)
     evt => evt%next
     do while (associated (evt))
        call evt%reset ()
        evt => evt%next
     end do
   end subroutine event_set_hard_particle_set
 
 @ %def event_set_hard_particle_set
 @
 Set the $\alpha_s$ value that should be used in a recalculation.  This should
 be called only if we explicitly want to override the QCD setting of the
 process core.
 <<Events: event: TBP>>=
   procedure :: set_alpha_qcd_forced => event_set_alpha_qcd_forced
 <<Events: procedures>>=
   subroutine event_set_alpha_qcd_forced (event, alpha_qcd)
     class(event_t), intent(inout) :: event
     real(default), intent(in) :: alpha_qcd
     if (allocated (event%alpha_qcd_forced)) then
        event%alpha_qcd_forced = alpha_qcd
     else
        allocate (event%alpha_qcd_forced, source = alpha_qcd)
     end if
   end subroutine event_set_alpha_qcd_forced
 
 @ %def event_set_alpha_qcd_forced
 @
 Analogously, for the common scale.  This forces also renormalization and
 factorization scale.
 <<Events: event: TBP>>=
   procedure :: set_scale_forced => event_set_scale_forced
 <<Events: procedures>>=
   subroutine event_set_scale_forced (event, scale)
     class(event_t), intent(inout) :: event
     real(default), intent(in) :: scale
     if (allocated (event%scale_forced)) then
        event%scale_forced = scale
     else
        allocate (event%scale_forced, source = scale)
     end if
   end subroutine event_set_scale_forced
 
 @ %def event_set_scale_forced
 @
 Here we try to recover an event from the [[particle_set]] subobject
 and recalculate the structure functions and matrix elements.  We
 have the appropriate [[process]] object and an initialized
 [[process_instance]] at hand, so beam and configuration data are
 known.  From the [[particle_set]], we get the momenta.
 
 The quantum-number information may be incomplete, e.g., helicity
 information may be partial or absent.  We recover the event just from
 the momentum configuration.
 
 We do not transfer the matrix element from the process instance to the
 event record, as we do when generating an event.  The event record may
 contain the matrix element as read from file, and the current
 calculation may use different parameters.  We thus can compare old and
 new values.
 
 The event [[weight]] may also be known already.  If yes, we pass it to the
 [[evaluate_event_data]] procedure.  It should already be normalized.  If we
 have an [[weight_factor]] value, we obtain the event weight by multiplying the
 computed [[sqme]] by this factor.  Otherwise, we make use of the MCI setup
 (which should be valid then) to compute the event weight, and we should
 normalize the result just as when generating events.
 
 Evaluating event expressions must also be done separately.
 
 If [[recover_phs]] is set (and false), do not attempt any phase-space
 calculation, including MCI evaluation.  Useful if we need only matrix elements.
 <<Events: event: TBP>>=
   procedure :: recalculate => event_recalculate
 <<Events: procedures>>=
   subroutine event_recalculate &
        (event, update_sqme, weight_factor, recover_beams, recover_phs)
     class(event_t), intent(inout) :: event
     logical, intent(in) :: update_sqme
     real(default), intent(in), optional :: weight_factor
     logical, intent(in), optional :: recover_beams
     logical, intent(in), optional :: recover_phs
     type(particle_set_t), pointer :: particle_set
     integer :: i_mci, i_term, channel
     logical :: rec_phs_mci
     rec_phs_mci = .true.;  if (present (recover_phs))  rec_phs_mci = recover_phs
     if (event%has_valid_particle_set ()) then
        particle_set => event%get_particle_set_ptr ()
        i_mci = event%selected_i_mci
        i_term = event%selected_i_term
        channel = event%selected_channel
        if (i_mci == 0 .or. i_term == 0 .or. channel == 0) then
           call msg_bug ("Event: recalculate: undefined selection parameters")
        end if
        call event%instance%choose_mci (i_mci)
        call event%instance%set_trace (particle_set, i_term, recover_beams)
        if (allocated (event%alpha_qcd_forced)) then
           call event%instance%set_alpha_qcd_forced &
                (i_term, event%alpha_qcd_forced)
        end if
        call event%instance%recover (channel, i_term, &
             update_sqme, rec_phs_mci, event%scale_forced)
        if (signal_is_pending ())  return
        if (update_sqme .and. present (weight_factor)) then
           call event%instance%evaluate_event_data &
                (weight = event%instance%get_sqme () * weight_factor)
        else if (event%weight_ref_is_known ()) then
           call event%instance%evaluate_event_data &
                (weight = event%get_weight_ref ())
        else if (rec_phs_mci) then
           call event%instance%recover_event ()
           if (signal_is_pending ())  return
           call event%instance%evaluate_event_data ()
           if (event%config%unweighted) then
              call event%instance%normalize_weight ()
           end if
        end if
        if (signal_is_pending ())  return
        if (update_sqme) then
           call event%import_instance_results ()
        else
           call event%accept_sqme_ref ()
           call event%accept_weight_ref ()
        end if
     else
        call msg_bug ("Event: can't recalculate, particle set is undefined")
     end if
   end subroutine event_recalculate
 
 @ %def event_recalculate
 @
 \subsection{Access content}
 Pointer to the associated process object (the associated model).
 <<Events: event: TBP>>=
   procedure :: get_process_ptr => event_get_process_ptr
   procedure :: get_process_instance_ptr => event_get_process_instance_ptr
   procedure :: get_model_ptr => event_get_model_ptr
 <<Events: procedures>>=
   function event_get_process_ptr (event) result (ptr)
     class(event_t), intent(in) :: event
     type(process_t), pointer :: ptr
     ptr => event%process
   end function event_get_process_ptr
 
   function event_get_process_instance_ptr (event) result (ptr)
     class(event_t), intent(in) :: event
     type(process_instance_t), pointer :: ptr
     ptr => event%instance
   end function event_get_process_instance_ptr
 
   function event_get_model_ptr (event) result (model)
     class(event_t), intent(in) :: event
     class(model_data_t), pointer :: model
     if (associated (event%process)) then
        model => event%process%get_model_ptr ()
     else
        model => null ()
     end if
   end function event_get_model_ptr
 
 @ %def event_get_process_ptr
 @ %def event_get_process_instance_ptr
 @ %def event_get_model_ptr
 @ Return the current values of indices: the MCI group of components, the term
 index (different terms corresponding, potentially, to different effective
 kinematics), and the MC integration channel.  The [[i_mci]] call is delegated
 to the current process instance.
 <<Events: event: TBP>>=
   procedure :: get_i_mci => event_get_i_mci
   procedure :: get_i_term => event_get_i_term
   procedure :: get_channel => event_get_channel
 <<Events: procedures>>=
   function event_get_i_mci (event) result (i_mci)
     class(event_t), intent(in) :: event
     integer :: i_mci
     i_mci = event%selected_i_mci
   end function event_get_i_mci
 
   function event_get_i_term (event) result (i_term)
     class(event_t), intent(in) :: event
     integer :: i_term
     i_term = event%selected_i_term
   end function event_get_i_term
 
   function event_get_channel (event) result (channel)
     class(event_t), intent(in) :: event
     integer :: channel
     channel = event%selected_channel
   end function event_get_channel
 
 @ %def event_get_i_mci
 @ %def event_get_i_term
 @ %def event_get_channel
 @ This flag tells us whether the event consists just of a hard process
 (i.e., holds at most the first, trivial transform), or is a dressed
 events with additional transforms.
 <<Events: event: TBP>>=
   procedure :: has_transform => event_has_transform
 <<Events: procedures>>=
   function event_has_transform (event) result (flag)
     class(event_t), intent(in) :: event
     logical :: flag
     if (associated (event%transform_first)) then
        flag = associated (event%transform_first%next)
     else
        flag = .false.
     end if
   end function event_has_transform
 
 @ %def event_has_transform
 @ Return the currently selected normalization mode, or alternate
 normalization mode.
 <<Events: event: TBP>>=
   procedure :: get_norm_mode => event_get_norm_mode
 <<Events: procedures>>=
   elemental function event_get_norm_mode (event) result (norm_mode)
     class(event_t), intent(in) :: event
     integer :: norm_mode
     norm_mode = event%config%norm_mode
   end function event_get_norm_mode
 
 @ %def event_get_norm_mode
 @ Return the kinematical weight, defined as the ratio of event weight
 and squared matrix element.
 <<Events: event: TBP>>=
   procedure :: get_kinematical_weight => event_get_kinematical_weight
 <<Events: procedures>>=
   function event_get_kinematical_weight (event) result (f)
     class(event_t), intent(in) :: event
     real(default) :: f
     if (event%sqme_ref_is_known () .and. event%weight_ref_is_known () &
          .and. abs (event%get_sqme_ref ()) > 0) then
        f = event%get_weight_ref () / event%get_sqme_ref ()
     else
        f = 0
     end if
   end function event_get_kinematical_weight
 
 @ %def event_get_kinematical_weight
 @ Return data used by external event formats.
 <<Events: event: TBP>>=
   procedure :: has_index => event_has_index 
   procedure :: get_index => event_get_index 
   procedure :: get_fac_scale => event_get_fac_scale
   procedure :: get_alpha_s => event_get_alpha_s
   procedure :: get_sqrts => event_get_sqrts
   procedure :: get_polarization => event_get_polarization
   procedure :: get_beam_file => event_get_beam_file
   procedure :: get_process_name => event_get_process_name
 <<Events: procedures>>=
   function event_has_index (event) result (flag)
     class(event_t), intent(in) :: event
     logical :: flag
     flag = event%expr%has_event_index ()
   end function event_has_index
 
   function event_get_index (event) result (index)
     class(event_t), intent(in) :: event
     integer :: index
     index = event%expr%get_event_index ()
   end function event_get_index
 
   function event_get_fac_scale (event) result (fac_scale)
     class(event_t), intent(in) :: event
     real(default) :: fac_scale
     fac_scale = event%instance%get_fac_scale (event%selected_i_term)
   end function event_get_fac_scale
 
   function event_get_alpha_s (event) result (alpha_s)
     class(event_t), intent(in) :: event
     real(default) :: alpha_s
     alpha_s = event%instance%get_alpha_s (event%selected_i_term)
   end function event_get_alpha_s
 
   function event_get_sqrts (event) result (sqrts)
     class(event_t), intent(in) :: event
     real(default) :: sqrts
     sqrts = event%instance%get_sqrts ()
   end function event_get_sqrts
 
   function event_get_polarization (event) result (pol)
     class(event_t), intent(in) :: event
     real(default), dimension(2) :: pol
     pol = event%instance%get_polarization ()
   end function event_get_polarization
 
   function event_get_beam_file (event) result (file)
     class(event_t), intent(in) :: event
     type(string_t) :: file
     file = event%instance%get_beam_file ()
   end function event_get_beam_file
 
   function event_get_process_name (event) result (name)
     class(event_t), intent(in) :: event
     type(string_t) :: name
     name = event%instance%get_process_name ()
   end function event_get_process_name
 
 @ %def event_get_index
 @ %def event_get_fac_scale
 @ %def event_get_alpha_s
 @ %def event_get_sqrts
 @ %def event_get_polarization
 @ %def event_get_beam_file
 @ %def event_get_process_name
 @ Return the actual number of calls, as stored in the process instance.
 <<Events: event: TBP>>=
   procedure :: get_actual_calls_total => event_get_actual_calls_total
 <<Events: procedures>>=
   elemental function event_get_actual_calls_total (event) result (n)
     class(event_t), intent(in) :: event
     integer :: n
     if (associated (event%instance)) then
        n = event%instance%get_actual_calls_total ()
     else
        n = 0
     end if
   end function event_get_actual_calls_total
 
 @ %def event_get_actual_calls_total
 @
 Eliminate numerical noise in the [[subevt]] expression and in the event
 transforms (which includes associated process instances).
 <<Events: public>>=
   public :: pacify
 <<Events: interfaces>>=
   interface pacify
      module procedure pacify_event
   end interface pacify
 <<Events: procedures>>=
   subroutine pacify_event (event)
     class(event_t), intent(inout) :: event
     class(evt_t), pointer :: evt
     call event%pacify_particle_set ()
     if (event%expr%subevt_filled)  call pacify (event%expr)
     evt => event%transform_first
     do while (associated (evt))
        select type (evt)
        type is (evt_decay_t);  call pacify (evt)
        end select
        evt => evt%next
     end do
   end subroutine pacify_event
 
 @ %def pacify
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[events_ut.f90]]>>=
 <<File header>>
 
 module events_ut
   use unit_tests
   use events_uti
 
 <<Standard module head>>
 
 <<Events: public test>>
 
 contains
 
 <<Events: test driver>>
 
 end module events_ut
 @ %def events_ut
 @
 <<[[events_uti.f90]]>>=
 <<File header>>
 
 module events_uti
 
 <<Use kinds>>
 <<Use strings>>
   use os_interface
   use model_data
   use particles
   use process_libraries
   use process_stacks
   use event_transforms
   use decays
   use decays_ut, only: prepare_testbed
 
   use process, only: process_t
   use instances, only: process_instance_t
 
   use events
 
 <<Standard module head>>
 
 <<Events: test declarations>>
 
 contains
 
 <<Events: tests>>
 
 end module events_uti
 
 @ %def events_uti
 @ API: driver for the unit tests below.
 <<Events: public test>>=
   public :: events_test
 <<Events: test driver>>=
   subroutine events_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Events: execute tests>>
   end subroutine events_test
 
 @ %def events_test
 @
 \subsubsection{Empty event record}
 <<Events: execute tests>>=
   call test (events_1, "events_1", &
        "empty event record", &
        u, results)
 <<Events: test declarations>>=
   public :: events_1
 <<Events: tests>>=
   subroutine events_1 (u)
     integer, intent(in) :: u
     type(event_t), target :: event
 
     write (u, "(A)")  "* Test output: events_1"
     write (u, "(A)")  "*   Purpose: display an empty event object"
     write (u, "(A)")
 
     call event%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: events_1"
 
   end subroutine events_1
 
 @ %def events_1
 @
 \subsubsection{Simple event}
 <<Events: execute tests>>=
   call test (events_2, "events_2", &
        "generate event", &
        u, results)
 <<Events: test declarations>>=
   public :: events_2
 <<Events: tests>>=
   subroutine events_2 (u)
     use processes_ut, only: prepare_test_process, cleanup_test_process
     integer, intent(in) :: u
     type(event_t), allocatable, target :: event
     type(process_t), allocatable, target :: process
     type(process_instance_t), allocatable, target :: process_instance
     type(model_data_t), target :: model
 
     write (u, "(A)")  "* Test output: events_2"
     write (u, "(A)")  "*   Purpose: generate and display an event"
     write (u, "(A)")
 
     call model%init_test ()
 
     write (u, "(A)")  "* Generate test process event"
 
     allocate (process)
     allocate (process_instance)
     call prepare_test_process (process, process_instance, model)
     call process_instance%setup_event_data ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Initialize event object"
 
     allocate (event)
     call event%basic_init ()
     call event%connect (process_instance, process%get_model_ptr ())
 
     write (u, "(A)")
     write (u, "(A)")  "* Generate test process event"
 
     call process_instance%generate_weighted_event (1)
 
     write (u, "(A)")
     write (u, "(A)")  "* Fill event object"
     write (u, "(A)")
 
     call event%generate (1, [0.4_default, 0.4_default])
     call event%increment_index ()
     call event%evaluate_expressions ()
     call event%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call event%final ()
     deallocate (event)
 
     call cleanup_test_process (process, process_instance)
     deallocate (process_instance)
     deallocate (process)
 
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: events_2"
 
   end subroutine events_2
 
 @ %def events_2
 @
 \subsubsection{Recovering an event}
 Generate an event and store the particle set.  Then reset the event
 record, recall the particle set, and recover the event from that.
 
 Note: The extra [[particle_set_ptr]] auxiliary is a workaround for
 memory corruption in gfortran 4.7.
 <<Events: execute tests>>=
   call test (events_4, "events_4", &
        "recover event", &
        u, results)
 <<Events: test declarations>>=
   public :: events_4
 <<Events: tests>>=
   subroutine events_4 (u)
     use processes_ut, only: prepare_test_process, cleanup_test_process
     integer, intent(in) :: u
     type(event_t), allocatable, target :: event
     type(process_t), allocatable, target :: process
     type(process_instance_t), allocatable, target :: process_instance
     type(particle_set_t) :: particle_set
     type(particle_set_t), pointer :: particle_set_ptr
     type(model_data_t), target :: model
 
     write (u, "(A)")  "* Test output: events_4"
     write (u, "(A)")  "*   Purpose: generate and recover an event"
     write (u, "(A)")
 
     call model%init_test ()
 
     write (u, "(A)")  "* Generate test process event and save particle set"
     write (u, "(A)")
 
     allocate (process)
     allocate (process_instance)
     call prepare_test_process (process, process_instance, model)
     call process_instance%setup_event_data ()
 
     allocate (event)
     call event%basic_init ()
     call event%connect (process_instance, process%get_model_ptr ())
 
     call event%generate (1, [0.4_default, 0.4_default])
     call event%increment_index ()
     call event%evaluate_expressions ()
     call event%write (u)
 
     particle_set_ptr => event%get_particle_set_ptr ()
     particle_set = particle_set_ptr
 
     call event%final ()
     deallocate (event)
 
     call cleanup_test_process (process, process_instance)
     deallocate (process_instance)
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Recover event from particle set"
     write (u, "(A)")
 
     allocate (process)
     allocate (process_instance)
     call prepare_test_process (process, process_instance, model)
     call process_instance%setup_event_data ()
 
     allocate (event)
     call event%basic_init ()
     call event%connect (process_instance, process%get_model_ptr ())
 
     call event%select (1, 1, 1)
     call event%set_hard_particle_set (particle_set)
     call event%recalculate (update_sqme = .true.)
     call event%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Transfer sqme and evaluate expressions"
     write (u, "(A)")
 
     call event%accept_sqme_prc ()
     call event%accept_weight_prc ()
     call event%check ()
     call event%set_index (1)
     call event%evaluate_expressions ()
     call event%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Reset contents"
     write (u, "(A)")
 
     call event%reset_contents ()
     call event%reset_index ()
     event%transform_first%particle_set_exists = .false.
     call event%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call particle_set%final ()
 
     call event%final ()
     deallocate (event)
 
     call cleanup_test_process (process, process_instance)
     deallocate (process_instance)
     deallocate (process)
 
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: events_4"
 
   end subroutine events_4
 
 @ %def events_4
 @
 \subsubsection{Partially Recovering an event}
 Generate an event and store the particle set.  Then reset the event
 record, recall the particle set, and recover the event as far as possible
 without recomputing the squared matrix element.
 <<Events: execute tests>>=
   call test (events_5, "events_5", &
        "partially recover event", &
        u, results)
 <<Events: test declarations>>=
   public :: events_5
 <<Events: tests>>=
   subroutine events_5 (u)
     use processes_ut, only: prepare_test_process, cleanup_test_process
     integer, intent(in) :: u
     type(event_t), allocatable, target :: event
     type(process_t), allocatable, target :: process
     type(process_instance_t), allocatable, target :: process_instance
     type(particle_set_t) :: particle_set
     type(particle_set_t), pointer :: particle_set_ptr
     real(default) :: sqme, weight
     type(model_data_t), target :: model
 
     write (u, "(A)")  "* Test output: events_5"
     write (u, "(A)")  "*   Purpose: generate and recover an event"
     write (u, "(A)")
 
     call model%init_test ()
 
     write (u, "(A)")  "* Generate test process event and save particle set"
     write (u, "(A)")
 
     allocate (process)
     allocate (process_instance)
     call prepare_test_process (process, process_instance, model)
     call process_instance%setup_event_data ()
 
     allocate (event)
     call event%basic_init ()
     call event%connect (process_instance, process%get_model_ptr ())
 
     call event%generate (1, [0.4_default, 0.4_default])
     call event%increment_index ()
     call event%evaluate_expressions ()
     call event%write (u)
 
     particle_set_ptr => event%get_particle_set_ptr ()
     particle_set = particle_set_ptr
     sqme = event%get_sqme_ref ()
     weight = event%get_weight_ref ()
 
     call event%final ()
     deallocate (event)
 
     call cleanup_test_process (process, process_instance)
     deallocate (process_instance)
     deallocate (process)
 
     write (u, "(A)")
     write (u, "(A)")  "* Recover event from particle set"
     write (u, "(A)")
 
     allocate (process)
     allocate (process_instance)
     call prepare_test_process (process, process_instance, model)
     call process_instance%setup_event_data ()
 
     allocate (event)
     call event%basic_init ()
     call event%connect (process_instance, process%get_model_ptr ())
 
     call event%select (1, 1, 1)
     call event%set_hard_particle_set (particle_set)
     call event%recalculate (update_sqme = .false.)
     call event%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Manually set sqme and evaluate expressions"
     write (u, "(A)")
 
     call event%set (sqme_ref = sqme, weight_ref = weight)
     call event%accept_sqme_ref ()
     call event%accept_weight_ref ()
     call event%set_index (1)
     call event%evaluate_expressions ()
     call event%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call particle_set%final ()
 
     call event%final ()
     deallocate (event)
 
     call cleanup_test_process (process, process_instance)
     deallocate (process_instance)
     deallocate (process)
 
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: events_5"
 
   end subroutine events_5
 
 @ %def events_5
 @
 \subsubsection{Decays}
 Generate an event with subsequent decays.
 <<Events: execute tests>>=
   call test (events_6, "events_6", &
        "decays", &
        u, results)
 <<Events: test declarations>>=
   public :: events_6
 <<Events: tests>>=
   subroutine events_6 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     class(model_data_t), pointer :: model
     type(string_t) :: prefix, procname1, procname2
     type(process_library_t), target :: lib
     type(process_stack_t) :: process_stack
     class(evt_t), pointer :: evt_decay
     type(event_t), allocatable, target :: event
     type(process_t), pointer :: process
     type(process_instance_t), allocatable, target :: process_instance
 
     write (u, "(A)")  "* Test output: events_6"
     write (u, "(A)")  "*   Purpose: generate an event with subsequent decays"
     write (u, "(A)")
 
     write (u, "(A)")  "* Generate test process and decay"
     write (u, "(A)")
 
     call os_data_init (os_data)
 
     prefix = "events_6"
     procname1 = prefix // "_p"
     procname2 = prefix // "_d"
     call prepare_testbed &
          (lib, process_stack, prefix, os_data, &
          scattering=.true., decay=.true.)
 
     write (u, "(A)")  "* Initialize decay process"
 
     process => process_stack%get_process_ptr (procname1)
     model => process%get_model_ptr ()
     call model%set_unstable (25, [procname2])
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%setup_event_data ()
     call process_instance%init_simulation (1)
 
     write (u, "(A)")
     write (u, "(A)")  "* Initialize event transform: decay"
 
     allocate (evt_decay_t :: evt_decay)
     call evt_decay%connect (process_instance, model, process_stack)
 
     write (u, "(A)")
     write (u, "(A)")  "* Initialize event object"
     write (u, "(A)")
 
     allocate (event)
     call event%basic_init ()
     call event%connect (process_instance, model)
     call event%import_transform (evt_decay)
 
     call event%write (u, show_decay = .true.)
 
     write (u, "(A)")
     write (u, "(A)")  "* Generate event"
     write (u, "(A)")
 
     call event%generate (1, [0.4_default, 0.4_default])
     call event%increment_index ()
     call event%evaluate_expressions ()
     call event%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call event%final ()
     deallocate (event)
 
     call process_instance%final ()
     deallocate (process_instance)
 
     call process_stack%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: events_6"
 
   end subroutine events_6
 
 @ %def events_6
 @
 \subsubsection{Decays}
 Generate a decay event with varying options.
 <<Events: execute tests>>=
   call test (events_7, "events_7", &
        "decay options", &
        u, results)
 <<Events: test declarations>>=
   public :: events_7
 <<Events: tests>>=
   subroutine events_7 (u)
     integer, intent(in) :: u
     type(os_data_t) :: os_data
     class(model_data_t), pointer :: model
     type(string_t) :: prefix, procname2
     type(process_library_t), target :: lib
     type(process_stack_t) :: process_stack
     type(process_t), pointer :: process
     type(process_instance_t), allocatable, target :: process_instance
 
     write (u, "(A)")  "* Test output: events_7"
     write (u, "(A)")  "*   Purpose: check decay options"
     write (u, "(A)")
 
     write (u, "(A)")  "* Prepare test process"
     write (u, "(A)")
 
     call os_data_init (os_data)
 
     prefix = "events_7"
     procname2 = prefix // "_d"
     call prepare_testbed &
          (lib, process_stack, prefix, os_data, &
          scattering=.false., decay=.true.)
 
     write (u, "(A)")  "* Generate decay event, default options"
     write (u, "(A)")
 
     process => process_stack%get_process_ptr (procname2)
     model => process%get_model_ptr ()
     call model%set_unstable (25, [procname2])
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%setup_event_data (model)
     call process_instance%init_simulation (1)
 
     call process_instance%generate_weighted_event (1)
     call process_instance%write (u)
 
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Generate decay event, helicity-diagonal decay"
     write (u, "(A)")
 
     process => process_stack%get_process_ptr (procname2)
     model => process%get_model_ptr ()
     call model%set_unstable (25, [procname2], diagonal = .true.)
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%setup_event_data (model)
     call process_instance%init_simulation (1)
 
     call process_instance%generate_weighted_event (1)
     call process_instance%write (u)
 
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Generate decay event, isotropic decay, &
          &polarized final state"
     write (u, "(A)")
 
     process => process_stack%get_process_ptr (procname2)
     model => process%get_model_ptr ()
     call model%set_unstable (25, [procname2], isotropic = .true.)
     call model%set_polarized (6)
     call model%set_polarized (-6)
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%setup_event_data (model)
     call process_instance%init_simulation (1)
 
     call process_instance%generate_weighted_event (1)
     call process_instance%write (u)
 
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call process_stack%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: events_7"
 
   end subroutine events_7
 
 @ %def events_7
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Raw Event I/O}
 The raw format is for internal use only.  All data are stored
 unformatted, so they can be efficiently be re-read on the same
 machine, but not necessarily on another machine.
 
 This module explicitly depends on the [[events]] module which provides the
 concrete implementation of [[event_base]].  The other I/O formats
 access only the methods that are defined in [[event_base]].
 <<[[eio_raw.f90]]>>=
 <<File header>>
 
 module eio_raw
 
 <<Use kinds>>
 <<Use strings>>
   use io_units
   use diagnostics
   use model_data
   use particles
   use event_base
   use eio_data
   use eio_base
   use events
 
 <<Standard module head>>
 
 <<EIO raw: public>>
 
 <<EIO raw: parameters>>
 
 <<EIO raw: types>>
 
 contains
 
 <<EIO raw: procedures>>
 
 end module eio_raw
 @ %def eio_raw
 @
 \subsection{File Format Version}
 This is the current default file version.
 <<EIO raw: parameters>>=
   integer, parameter :: CURRENT_FILE_VERSION = 2
 
 @ %def CURRENT_FILE_VERSION
 @ The user may change this number; this should force some
 compatibility mode for reading and writing.  In any case, the file
 version stored in a event file that we read has to match the expected
 file version.
 
 History of version numbers:
 \begin{enumerate}
 \item
   Format for WHIZARD 2.2.0 to 2.2.3.  No version number stored in the raw file.
 \item
   Format from 2.2.4 on.  File contains version number.  The file
   contains the transformed particle set (if applicable) after the
   hard-process particle set.
 \end{enumerate}
 @
 \subsection{Type}
 Note the file version number.  The default may be reset during
 initialization, which should enforce some compatibility mode.
 <<EIO raw: public>>=
   public :: eio_raw_t
 <<EIO raw: types>>=
   type, extends (eio_t) :: eio_raw_t
      logical :: reading = .false.
      logical :: writing = .false.
      integer :: unit = 0
      integer :: norm_mode = NORM_UNDEFINED
      real(default) :: sigma = 1
      integer :: n = 1
      integer :: n_alt = 0
      logical :: check = .false.
      integer :: file_version = CURRENT_FILE_VERSION
    contains
    <<EIO raw: eio raw: TBP>>
   end type eio_raw_t
 
 @ %def eio_raw_t
 @ Output.  This is not the actual event format, but a readable account
 of the current object status.
 <<EIO raw: eio raw: TBP>>=
   procedure :: write => eio_raw_write
 <<EIO raw: procedures>>=
   subroutine eio_raw_write (object, unit)
     class(eio_raw_t), intent(in) :: object
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     write (u, "(1x,A)")  "Raw event stream:"
     write (u, "(3x,A,L1)")  "Check MD5 sum     = ", object%check
     if (object%n_alt > 0) then
        write (u, "(3x,A,I0)")  "Alternate weights = ", object%n_alt
     end if
     if (object%reading) then
        write (u, "(3x,A,A)")  "Reading from file = ", char (object%filename)
     else if (object%writing) then
        write (u, "(3x,A,A)")  "Writing to file   = ", char (object%filename)
     else
        write (u, "(3x,A)")  "[closed]"
     end if
   end subroutine eio_raw_write
 
 @ %def eio_raw_write
 @ Finalizer: close any open file.
 <<EIO raw: eio raw: TBP>>=
   procedure :: final => eio_raw_final
 <<EIO raw: procedures>>=
   subroutine eio_raw_final (object)
     class(eio_raw_t), intent(inout) :: object
     if (object%reading .or. object%writing) then
        write (msg_buffer, "(A,A,A)")  "Events: closing raw file '", &
             char (object%filename), "'"
        call msg_message ()
        close (object%unit)
        object%reading = .false.
        object%writing = .false.
     end if
   end subroutine eio_raw_final
 
 @ %def eio_raw_final
 @ Set the [[check]] flag which determines whether we compare checksums on input.
 <<EIO raw: eio raw: TBP>>=
   procedure :: set_parameters => eio_raw_set_parameters
 <<EIO raw: procedures>>=
   subroutine eio_raw_set_parameters (eio, check, version_string, extension)
     class(eio_raw_t), intent(inout) :: eio
     logical, intent(in), optional :: check
     type(string_t), intent(in), optional :: version_string
     type(string_t), intent(in), optional :: extension
     if (present (check))  eio%check = check
     if (present (version_string)) then
        select case (char (version_string))
        case ("", "2.2.4")
           eio%file_version = CURRENT_FILE_VERSION
        case ("2.2")
           eio%file_version = 1
        case default
           call msg_fatal ("Raw event I/O: unsupported version '" &
                // char (version_string) // "'")
           eio%file_version = 0
        end select
     end if
     if (present (extension)) then
        eio%extension = extension
     else
        eio%extension = "evx"
     end if
   end subroutine eio_raw_set_parameters
 
 @ %def eio_raw_set_parameters
 @ Initialize event writing.
 <<EIO raw: eio raw: TBP>>=
   procedure :: init_out => eio_raw_init_out
 <<EIO raw: procedures>>=
   subroutine eio_raw_init_out (eio, sample, data, success, extension)
     class(eio_raw_t), intent(inout) :: eio
     type(string_t), intent(in) :: sample
     type(event_sample_data_t), intent(in), optional :: data
     logical, intent(out), optional :: success
     type(string_t), intent(in), optional :: extension
     character(32) :: md5sum_prc, md5sum_cfg
     character(32), dimension(:), allocatable :: md5sum_alt
     integer :: i
     if (present (extension)) then
        eio%extension  = extension
     else
        eio%extension = "evx"
     end if
     eio%filename = sample // "." // eio%extension
     eio%unit = free_unit ()
     write (msg_buffer, "(A,A,A)")  "Events: writing to raw file '", &
          char (eio%filename), "'"
     call msg_message ()
     eio%writing = .true.
     if (present (data)) then
        md5sum_prc = data%md5sum_prc
        md5sum_cfg = data%md5sum_cfg
        eio%norm_mode = data%norm_mode
        eio%sigma = data%total_cross_section
        eio%n = data%n_evt
        eio%n_alt = data%n_alt
        if (eio%n_alt > 0) then
           !!! !!! !!! Workaround for gfortran 5.0 ICE
           allocate (md5sum_alt (data%n_alt))
           md5sum_alt = data%md5sum_alt
           !!! allocate (md5sum_alt (data%n_alt), source = data%md5sum_alt)
        end if
     else
        md5sum_prc = ""
        md5sum_cfg = ""
     end if
     open (eio%unit, file = char (eio%filename), form = "unformatted", &
          action = "write", status = "replace")
     select case (eio%file_version)
     case (2:);  write (eio%unit)  eio%file_version
     end select
     write (eio%unit)  md5sum_prc
     write (eio%unit)  md5sum_cfg
     write (eio%unit)  eio%norm_mode
     write (eio%unit)  eio%n_alt
     if (allocated (md5sum_alt)) then
        do i = 1, eio%n_alt
           write (eio%unit)  md5sum_alt(i)
        end do
     end if
     if (present (success))  success = .true.
   end subroutine eio_raw_init_out
 
 @ %def eio_raw_init_out
 @ Initialize event reading.
 <<EIO raw: eio raw: TBP>>=
   procedure :: init_in => eio_raw_init_in
 <<EIO raw: procedures>>=
   subroutine eio_raw_init_in (eio, sample, data, success, extension)
     class(eio_raw_t), intent(inout) :: eio
     type(string_t), intent(in) :: sample
     type(event_sample_data_t), intent(inout), optional :: data
     logical, intent(out), optional :: success
     type(string_t), intent(in), optional :: extension
     character(32) :: md5sum_prc, md5sum_cfg
     character(32), dimension(:), allocatable :: md5sum_alt
     integer :: i, file_version
     if (present (success))  success = .true.
     if (present (extension)) then
        eio%extension = extension
     else
        eio%extension = "evx"
     end if
     eio%filename = sample // "." // eio%extension
     eio%unit = free_unit ()
     if (present (data)) then
        eio%sigma = data%total_cross_section
        eio%n = data%n_evt
     end if
     write (msg_buffer, "(A,A,A)")  "Events: reading from raw file '", &
          char (eio%filename), "'"
     call msg_message ()
     eio%reading = .true.
     open (eio%unit, file = char (eio%filename), form = "unformatted", &
          action = "read", status = "old")
     select case (eio%file_version)
     case (2:);  read (eio%unit)  file_version
     case default;  file_version = 1
     end select
     if (file_version /= eio%file_version) then
        call msg_error ("Reading event file: raw-file version mismatch.")
        if (present (success))  success = .false.
        return
     else if (file_version /= CURRENT_FILE_VERSION) then
        call msg_warning ("Reading event file: compatibility mode.")
     end if
     read (eio%unit)  md5sum_prc
     read (eio%unit)  md5sum_cfg
     read (eio%unit)  eio%norm_mode
     read (eio%unit)  eio%n_alt
     if (present (data)) then
        if (eio%n_alt /= data%n_alt) then
           if (present (success))  success = .false.
           return
        end if
     end if
     allocate (md5sum_alt (eio%n_alt))
     do i = 1, eio%n_alt
        read (eio%unit)  md5sum_alt(i)
     end do
     if (present (success)) then
        if (present (data)) then
           if (eio%check) then
              if (data%md5sum_prc /= "") then
                 success = success .and. md5sum_prc == data%md5sum_prc
              end if
              if (data%md5sum_cfg /= "") then
                 success = success .and. md5sum_cfg == data%md5sum_cfg
              end if
              do i = 1, eio%n_alt
                 if (data%md5sum_alt(i) /= "") then
                    success = success .and. md5sum_alt(i) == data%md5sum_alt(i)
                 end if
              end do
           else
              call msg_warning ("Reading event file: MD5 sum check disabled")
           end if
        end if
     end if
   end subroutine eio_raw_init_in
 
 @ %def eio_raw_init_in
 @ Switch from input to output: reopen the file for reading.
 <<EIO raw: eio raw: TBP>>=
   procedure :: switch_inout => eio_raw_switch_inout
 <<EIO raw: procedures>>=
   subroutine eio_raw_switch_inout (eio, success)
     class(eio_raw_t), intent(inout) :: eio
     logical, intent(out), optional :: success
     write (msg_buffer, "(A,A,A)")  "Events: appending to raw file '", &
          char (eio%filename), "'"
     call msg_message ()
     close (eio%unit, status = "keep")
     eio%reading = .false.
     open (eio%unit, file = char (eio%filename), form = "unformatted", &
          action = "write", position = "append", status = "old")
     eio%writing = .true.
     if (present (success))  success = .true.
   end subroutine eio_raw_switch_inout
 
 @ %def eio_raw_switch_inout
 @ Output an event.  Write first the event indices, then weight and
 squared matrix element, then the particle set.
 
 We always write the particle set of the hard process.  (Note: this
 should be reconsidered.)  We do make a physical copy.
 
 On output, we write the [[prc]] values for weight and sqme, since
 these are the values just computed.  On input, we store the values as
 [[ref]] values.  The caller can then decide whether to recompute
 values and thus obtain distinct [[prc]] values, or just accept them.
 
 The [[passed]] flag is not written.  This allow us to apply different
 selection criteria upon rereading.
 <<EIO raw: eio raw: TBP>>=
   procedure :: output => eio_raw_output
 <<EIO raw: procedures>>=
   subroutine eio_raw_output (eio, event, i_prc, reading, passed, pacify)
     class(eio_raw_t), intent(inout) :: eio
     class(generic_event_t), intent(in), target :: event
     logical, intent(in), optional :: reading, passed, pacify
     integer, intent(in) :: i_prc
     type(particle_set_t), pointer :: pset
     integer :: i
     if (eio%writing) then
        if (event%has_valid_particle_set ()) then
           select type (event)
           type is (event_t)
              write (eio%unit)  i_prc
              write (eio%unit)  event%get_index ()
              write (eio%unit)  event%get_i_mci ()
              write (eio%unit)  event%get_i_term ()
              write (eio%unit)  event%get_channel ()
              write (eio%unit)  event%expr%weight_prc
              write (eio%unit)  event%expr%excess_prc
              write (eio%unit)  event%expr%sqme_prc
              do i = 1, eio%n_alt
                 write (eio%unit)  event%expr%weight_alt(i)
                 write (eio%unit)  event%expr%sqme_alt(i)
              end do
              allocate (pset)
              call event%get_hard_particle_set (pset)
              call pset%write_raw (eio%unit)
              call pset%final ()
              deallocate (pset)
              select case (eio%file_version)
              case (2:)
                 if (event%has_transform ()) then
                    write (eio%unit)  .true.
                    pset => event%get_particle_set_ptr ()
                    call pset%write_raw (eio%unit)
                 else
                    write (eio%unit)  .false.
                 end if
              end select
           class default
              call msg_bug ("Event: write raw: defined only for full event_t")
           end select
        else
           call msg_bug ("Event: write raw: particle set is undefined")
        end if
     else
        call eio%write ()
        call msg_fatal ("Raw event file is not open for writing")
     end if
   end subroutine eio_raw_output
 
 @ %def eio_raw_output
 @ Input an event.
 
 Note: the particle set is physically copied.  If there is a
 performance issue, we might choose to pointer-assign it instead, with
 a different version of [[event%set_hard_particle_set]].
 <<EIO raw: eio raw: TBP>>=
   procedure :: input_i_prc => eio_raw_input_i_prc
   procedure :: input_event => eio_raw_input_event
 <<EIO raw: procedures>>=
   subroutine eio_raw_input_i_prc (eio, i_prc, iostat)
     class(eio_raw_t), intent(inout) :: eio
     integer, intent(out) :: i_prc
     integer, intent(out) :: iostat
     if (eio%reading) then
        read (eio%unit, iostat = iostat)  i_prc
     else
        call eio%write ()
        call msg_fatal ("Raw event file is not open for reading")
     end if
   end subroutine eio_raw_input_i_prc
 
   subroutine eio_raw_input_event (eio, event, iostat)
     class(eio_raw_t), intent(inout) :: eio
     class(generic_event_t), intent(inout), target :: event
     integer, intent(out) :: iostat
     integer :: event_index, i_mci, i_term, channel, i
     real(default) :: weight, excess, sqme
     real(default), dimension(:), allocatable :: weight_alt, sqme_alt
     logical :: has_transform
     type(particle_set_t), pointer :: pset
     class(model_data_t), pointer :: model
     if (eio%reading) then
        select type (event)
        type is (event_t)
           read (eio%unit, iostat = iostat)  event_index
           if (iostat /= 0)  return
           read (eio%unit, iostat = iostat)  i_mci
           if (iostat /= 0)  return
           read (eio%unit, iostat = iostat)  i_term
           if (iostat /= 0)  return
           read (eio%unit, iostat = iostat)  channel
           if (iostat /= 0)  return
           read (eio%unit, iostat = iostat)  weight
           if (iostat /= 0)  return
           read (eio%unit, iostat = iostat)  excess
           if (iostat /= 0)  return
           read (eio%unit, iostat = iostat)  sqme
           if (iostat /= 0)  return
           call event%reset_contents ()
           call event%set_index (event_index)
           call event%select (i_mci, i_term, channel)
           if (eio%norm_mode /= NORM_UNDEFINED) then
              call event_normalization_update (weight, &
                   eio%sigma, eio%n, event%get_norm_mode (), eio%norm_mode)
              call event_normalization_update (excess, &
                   eio%sigma, eio%n, event%get_norm_mode (), eio%norm_mode)
           end if
           call event%set (sqme_ref = sqme, weight_ref = weight, &
                excess_prc = excess)
           if (eio%n_alt /= 0) then
              allocate (sqme_alt (eio%n_alt), weight_alt (eio%n_alt))
              do i = 1, eio%n_alt
                 read (eio%unit, iostat = iostat)  weight_alt(i)
                 if (iostat /= 0)  return
                 read (eio%unit, iostat = iostat)  sqme_alt(i)
                 if (iostat /= 0)  return
              end do
              call event%set (sqme_alt = sqme_alt, weight_alt = weight_alt)
           end if
           model => null ()
           if (associated (event%process)) then
              model => event%process%get_model_ptr ()
           end if
           allocate (pset)
           call pset%read_raw (eio%unit, iostat)
           if (iostat /= 0)  return
           if (associated (model))  call pset%set_model (model)
           call event%set_hard_particle_set (pset)
           call pset%final ()
           deallocate (pset)
           select case (eio%file_version)
           case (2:)
              read (eio%unit, iostat = iostat)  has_transform
              if (iostat /= 0)  return
              if (has_transform) then
                 allocate (pset)
                 call pset%read_raw (eio%unit, iostat)
                 if (iostat /= 0)  return
                 if (associated (model)) &
                      call pset%set_model (model)
                 call event%link_particle_set (pset)
              end if
           end select
        class default
           call msg_bug ("Event: read raw: defined only for full event_t")
        end select
     else
        call eio%write ()
        call msg_fatal ("Raw event file is not open for reading")
     end if
   end subroutine eio_raw_input_event
 
 @ %def eio_raw_input_i_prc
 @ %def eio_raw_input_event
 @
 <<EIO raw: eio raw: TBP>>=
   procedure :: skip => eio_raw_skip
 <<EIO raw: procedures>>=
   subroutine eio_raw_skip (eio, iostat)
     class(eio_raw_t), intent(inout) :: eio
     integer, intent(out) :: iostat
     if (eio%reading) then
        read (eio%unit, iostat = iostat)
     else
        call eio%write ()
        call msg_fatal ("Raw event file is not open for reading")
     end if
   end subroutine eio_raw_skip
 
 @ %def eio_raw_skip
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[eio_raw_ut.f90]]>>=
 <<File header>>
 
 module eio_raw_ut
   use unit_tests
   use eio_raw_uti
 
 <<Standard module head>>
 
 <<EIO raw: public test>>
 
 contains
 
 <<EIO raw: test driver>>
 
 end module eio_raw_ut
 @ %def eio_raw_ut
 @
 <<[[eio_raw_uti.f90]]>>=
 <<File header>>
 
 module eio_raw_uti
 
 <<Use kinds>>
 <<Use strings>>
   use model_data
   use variables
   use events
   use eio_data
   use eio_base
 
   use eio_raw
 
   use process, only: process_t
   use instances, only: process_instance_t
 
 <<Standard module head>>
 
 <<EIO raw: test declarations>>
 
 contains
 
 <<EIO raw: tests>>
 
 end module eio_raw_uti
 
 @ %def eio_raw_uti
 @ API: driver for the unit tests below.
 <<EIO raw: public test>>=
   public :: eio_raw_test
 <<EIO raw: test driver>>=
   subroutine eio_raw_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<EIO raw: execute tests>>
   end subroutine eio_raw_test
 
 @ %def eio_raw_test
 @
 \subsubsection{Test I/O methods}
 We test the implementation of all I/O methods.
 <<EIO raw: execute tests>>=
   call test (eio_raw_1, "eio_raw_1", &
        "read and write event contents", &
        u, results)
 <<EIO raw: test declarations>>=
   public :: eio_raw_1
 <<EIO raw: tests>>=
   subroutine eio_raw_1 (u)
     use processes_ut, only: prepare_test_process, cleanup_test_process
     integer, intent(in) :: u
     type(model_data_t), target :: model
     type(event_t), allocatable, target :: event
     type(process_t), allocatable, target :: process
     type(process_instance_t), allocatable, target :: process_instance
     class(eio_t), allocatable :: eio
     integer :: i_prc, iostat
     type(string_t) :: sample
 
     write (u, "(A)")  "* Test output: eio_raw_1"
     write (u, "(A)")  "*   Purpose: generate and read/write an event"
     write (u, "(A)")
 
     write (u, "(A)")  "* Initialize test process"
 
     call model%init_test ()
 
     allocate (process)
     allocate (process_instance)
     call prepare_test_process (process, process_instance, model)
     call process_instance%setup_event_data ()
 
     allocate (event)
     call event%basic_init ()
     call event%connect (process_instance, process%get_model_ptr ())
 
     write (u, "(A)")
     write (u, "(A)")  "* Generate and write an event"
     write (u, "(A)")
 
     sample = "eio_raw_1"
 
     allocate (eio_raw_t :: eio)
 
     call eio%init_out (sample)
     call event%generate (1, [0._default, 0._default])
     call event%increment_index ()
     call event%evaluate_expressions ()
     call event%write (u)
     write (u, "(A)")
 
     call eio%output (event, i_prc = 42)
     call eio%write (u)
     call eio%final ()
 
     call event%final ()
     deallocate (event)
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Re-read the event"
     write (u, "(A)")
 
     call eio%init_in (sample)
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%setup_event_data ()
     allocate (event)
     call event%basic_init ()
     call event%connect (process_instance, process%get_model_ptr ())
 
     call eio%input_i_prc (i_prc, iostat)
     if (iostat /= 0)  write (u, "(A,I0)")  "I/O error (i_prc):", iostat
     call eio%input_event (event, iostat)
     if (iostat /= 0)  write (u, "(A,I0)")  "I/O error (event):", iostat
     call eio%write (u)
 
     write (u, "(A)")
     write (u, "(1x,A,I0)")  "i_prc = ", i_prc
     write (u, "(A)")
     call event%write (u)
     write (u, "(A)")
     write (u, "(A)")  "* Generate and append another event"
     write (u, "(A)")
 
     call eio%switch_inout ()
     call event%generate (1, [0._default, 0._default])
     call event%increment_index ()
     call event%evaluate_expressions ()
     call event%write (u)
     write (u, "(A)")
 
     call eio%output (event, i_prc = 5)
     call eio%write (u)
     call eio%final ()
 
     call event%final ()
     deallocate (event)
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Re-read both events"
     write (u, "(A)")
 
     call eio%init_in (sample)
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%setup_event_data ()
     allocate (event)
     call event%basic_init ()
     call event%connect (process_instance, process%get_model_ptr ())
 
     call eio%input_i_prc (i_prc, iostat)
     if (iostat /= 0)  write (u, "(A,I0)")  "I/O error (i_prc/1):", iostat
     call eio%input_event (event, iostat)
     if (iostat /= 0)  write (u, "(A,I0)")  "I/O error (event/1):", iostat
     call eio%input_i_prc (i_prc, iostat)
     if (iostat /= 0)  write (u, "(A,I0)")  "I/O error (i_prc/2):", iostat
     call eio%input_event (event, iostat)
     if (iostat /= 0)  write (u, "(A,I0)")  "I/O error (event/2):", iostat
     call eio%write (u)
 
     write (u, "(A)")
     write (u, "(1x,A,I0)")  "i_prc = ", i_prc
     write (u, "(A)")
     call event%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call eio%final ()
     deallocate (eio)
 
     call event%final ()
     deallocate (event)
 
     call cleanup_test_process (process, process_instance)
     deallocate (process_instance)
     deallocate (process)
 
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: eio_raw_1"
 
   end subroutine eio_raw_1
 
 @ %def eio_raw_1
 @
 \subsubsection{Test I/O methods}
 We test the implementation of all I/O methods.
 <<EIO raw: execute tests>>=
   call test (eio_raw_2, "eio_raw_2", &
        "handle multiple weights", &
        u, results)
 <<EIO raw: test declarations>>=
   public :: eio_raw_2
 <<EIO raw: tests>>=
   subroutine eio_raw_2 (u)
     use processes_ut, only: prepare_test_process, cleanup_test_process
     integer, intent(in) :: u
     type(model_data_t), target :: model
     type(var_list_t) :: var_list
     type(event_t), allocatable, target :: event
     type(process_t), allocatable, target :: process
     type(process_instance_t), allocatable, target :: process_instance
     type(event_sample_data_t) :: data
     class(eio_t), allocatable :: eio
     integer :: i_prc, iostat
     type(string_t) :: sample
 
     write (u, "(A)")  "* Test output: eio_raw_2"
     write (u, "(A)")  "*   Purpose: generate and read/write an event"
     write (u, "(A)")  "*            with multiple weights"
     write (u, "(A)")
 
     call model%init_test ()
 
     write (u, "(A)")  "* Initialize test process"
 
     allocate (process)
     allocate (process_instance)
     call prepare_test_process (process, process_instance, model)
     call process_instance%setup_event_data ()
 
     call data%init (n_proc = 1, n_alt = 2)
 
     call var_list_append_log (var_list, var_str ("?unweighted"), .false., &
          intrinsic = .true.)
     call var_list_append_string (var_list, var_str ("$sample_normalization"), &
          var_str ("auto"), intrinsic = .true.)
     call var_list_append_real (var_list, var_str ("safety_factor"), &
          1._default, intrinsic = .true.)
 
     allocate (event)
     call event%basic_init (var_list, n_alt = 2)
     call event%connect (process_instance, process%get_model_ptr ())
 
     write (u, "(A)")
     write (u, "(A)")  "* Generate and write an event"
     write (u, "(A)")
 
     sample = "eio_raw_2"
 
     allocate (eio_raw_t :: eio)
 
     call eio%init_out (sample, data)
     call event%generate (1, [0._default, 0._default])
     call event%increment_index ()
     call event%evaluate_expressions ()
     call event%set (sqme_alt = [2._default, 3._default])
     call event%set (weight_alt = &
          [2 * event%get_weight_ref (), 3 * event%get_weight_ref ()])
     call event%store_alt_values ()
     call event%check ()
 
     call event%write (u)
     write (u, "(A)")
 
     call eio%output (event, i_prc = 42)
     call eio%write (u)
     call eio%final ()
 
     call event%final ()
     deallocate (event)
     call process_instance%final ()
     deallocate (process_instance)
 
     write (u, "(A)")
     write (u, "(A)")  "* Re-read the event"
     write (u, "(A)")
 
     call eio%init_in (sample, data)
 
     allocate (process_instance)
     call process_instance%init (process)
     call process_instance%setup_event_data ()
     allocate (event)
     call event%basic_init (var_list, n_alt = 2)
     call event%connect (process_instance, process%get_model_ptr ())
 
     call eio%input_i_prc (i_prc, iostat)
     if (iostat /= 0)  write (u, "(A,I0)")  "I/O error (i_prc):", iostat
     call eio%input_event (event, iostat)
     if (iostat /= 0)  write (u, "(A,I0)")  "I/O error (event):", iostat
     call eio%write (u)
 
     write (u, "(A)")
     write (u, "(1x,A,I0)")  "i_prc = ", i_prc
     write (u, "(A)")
     call event%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call eio%final ()
     deallocate (eio)
 
     call event%final ()
     deallocate (event)
 
     call cleanup_test_process (process, process_instance)
     deallocate (process_instance)
     deallocate (process)
 
     call model%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: eio_raw_2"
 
   end subroutine eio_raw_2
 
 @ %def eio_raw_2
 @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Dispatch}
 An event transform is responsible for dressing a partonic event.
 Since event transforms are not mutually exclusive but are
 concatenated, we provide individual dispatchers for each of them.
 
 <<[[dispatch_transforms.f90]]>>=
 <<File header>>
 
 module dispatch_transforms
 
 <<Use kinds>>
 <<Use strings>>
   use process
   use variables
   use system_defs, only: LF
   use system_dependencies, only: LHAPDF6_AVAILABLE
   use sf_lhapdf, only: lhapdf_initialize
   use diagnostics
   use models
   use os_interface
   use beam_structures
   use resonances, only: resonance_history_set_t
   use instances, only: process_instance_t, process_instance_hook_t
 
   use event_base, only: event_callback_t, event_callback_nop_t
   use eio_base
   use eio_raw
   use eio_checkpoints
   use eio_callback
   use eio_lhef
   use eio_hepmc
   use eio_lcio
   use eio_stdhep
   use eio_ascii
   use eio_weights
   use eio_dump
 
   use event_transforms
   use resonance_insertion
   use isr_epa_handler
   use decays
   use shower_base
   use shower_core
   use shower
   use shower_pythia6
   use hadrons
   use mlm_matching
   use powheg_matching
   use ckkw_matching
   use tauola_interface !NODEP!
   use evt_nlo
 
 <<Standard module head>>
 
 <<Dispatch transforms: public>>
 
 contains
 
 <<Dispatch transforms: procedures>>
 
 end module dispatch_transforms
 @ %def dispatch_transforms
 @
 <<Dispatch transforms: public>>=
   public :: dispatch_evt_nlo
 <<Dispatch transforms: procedures>>=
   subroutine dispatch_evt_nlo (evt, keep_failed_events)
     class(evt_t), intent(out), pointer :: evt
     logical, intent(in) :: keep_failed_events
     call msg_message ("Simulate: activating fixed-order NLO events")
     allocate (evt_nlo_t :: evt)
     evt%only_weighted_events = .true.
     select type (evt)
     type is (evt_nlo_t)
        evt%i_evaluation = 0
        evt%keep_failed_events = keep_failed_events
     end select
   end subroutine dispatch_evt_nlo
 
 @ %def dispatch_evt_nlo
 @
 <<Dispatch transforms: public>>=
   public :: dispatch_evt_resonance
 <<Dispatch transforms: procedures>>=
   subroutine dispatch_evt_resonance (evt, var_list, res_history_set, libname)
     class(evt_t), intent(out), pointer :: evt
     type(var_list_t), intent(in) :: var_list
     type(resonance_history_set_t), dimension(:), intent(in) :: res_history_set
     type(string_t), intent(in) :: libname
     logical :: resonance_history
     resonance_history = var_list%get_lval (var_str ("?resonance_history"))
     if (resonance_history) then
        allocate (evt_resonance_t :: evt)
        call msg_message ("Simulate: activating resonance insertion")
        select type (evt)
        type is (evt_resonance_t)
           call evt%set_resonance_data (res_history_set)
           call evt%set_library (libname)
        end select
     else
        evt => null ()
     end if
   end subroutine dispatch_evt_resonance
 
 @ %def dispatch_evt_resonance
 @ Initialize the ISR/EPA handler, depending on active settings.
 
 The activation is independent for both handlers, since only one may be
 needed at a time.  However, if both handlers are active, the current
 implementation requires the handler modes of ISR and EPA to coincide.
 <<Dispatch transforms: public>>=
   public :: dispatch_evt_isr_epa_handler
 <<Dispatch transforms: procedures>>=
   subroutine dispatch_evt_isr_epa_handler (evt, var_list)
     class(evt_t), intent(out), pointer :: evt
     type(var_list_t), intent(in) :: var_list
     logical :: isr_recoil
     logical :: epa_recoil
     logical :: isr_handler_active
     logical :: epa_handler_active
     type(string_t) :: isr_handler_mode
     type(string_t) :: epa_handler_mode
     real(default) :: sqrts
     real(default) :: isr_q_max
     real(default) :: epa_q_max
     real(default) :: isr_mass
     real(default) :: epa_mass
     isr_handler_active = var_list%get_lval (var_str ("?isr_handler"))
     if (isr_handler_active) then
        call msg_message ("Simulate: activating ISR handler")
        isr_recoil = var_list%get_lval (var_str ("?isr_recoil"))
        isr_handler_mode = var_list%get_sval (var_str ("$isr_handler_mode"))
        if (isr_recoil) then
           call msg_fatal ("Simulate: ISR handler is incompatible &
                &with ?isr_recoil=true")
        end if
     end if
     epa_handler_active = var_list%get_lval (var_str ("?epa_handler"))
     if (epa_handler_active) then
        call msg_message ("Simulate: activating EPA handler")
        epa_recoil = var_list%get_lval (var_str ("?epa_recoil"))
        epa_handler_mode = var_list%get_sval (var_str ("$epa_handler_mode"))
        if (epa_recoil) then
           call msg_fatal ("Simulate: EPA handler is incompatible &
                &with ?epa_recoil=true")
        end if
     end if
     if (isr_handler_active .and. epa_handler_active) then
        if (isr_handler_mode /= epa_handler_mode) then
           call msg_fatal ("Simulate: ISR/EPA handler: modes must coincide")
        end if
     end if
     if (isr_handler_active .or. epa_handler_active) then
        allocate (evt_isr_epa_t :: evt)
        select type (evt)
        type is (evt_isr_epa_t)
           if (isr_handler_active) then
              call evt%set_mode_string (isr_handler_mode)
           else
              call evt%set_mode_string (epa_handler_mode)
           end if
           sqrts = var_list%get_rval (var_str ("sqrts"))
           if (isr_handler_active) then
              isr_q_max = var_list%get_rval (var_str ("isr_q_max"))
              isr_mass = var_list%get_rval (var_str ("isr_mass"))
              call evt%set_data_isr (sqrts, isr_q_max, isr_mass)
           end if
           if (epa_handler_active) then
              epa_q_max = var_list%get_rval (var_str ("epa_q_max"))
              epa_mass = var_list%get_rval (var_str ("epa_mass"))
              call evt%set_data_epa (sqrts, epa_q_max, epa_mass)
           end if
           call msg_message ("Simulate: ISR/EPA handler mode: " &
                // char (evt%get_mode_string ()))
        end select
     else
        evt => null ()
     end if
   end subroutine dispatch_evt_isr_epa_handler
 
 @ %def dispatch_evt_isr_epa_handler
 @
 <<Dispatch transforms: public>>=
   public :: dispatch_evt_decay
 <<Dispatch transforms: procedures>>=
   subroutine dispatch_evt_decay (evt, var_list)
     class(evt_t), intent(out), pointer :: evt
     type(var_list_t), intent(in), target :: var_list
     logical :: allow_decays
     allow_decays = var_list%get_lval (var_str ("?allow_decays"))
     if (allow_decays) then
        allocate (evt_decay_t :: evt)
        call msg_message ("Simulate: activating decays")
        select type (evt)
        type is (evt_decay_t)
           call evt%set_var_list (var_list)
        end select
     else
        evt => null ()
     end if
   end subroutine dispatch_evt_decay
 
 @ %def dispatch_evt_decay
 @
 <<Dispatch transforms: public>>=
   public :: dispatch_evt_shower
 <<Dispatch transforms: procedures>>=
   subroutine dispatch_evt_shower (evt, var_list, model, fallback_model, &
        os_data, beam_structure, process)
     class(evt_t), intent(out), pointer :: evt
     type(var_list_t), intent(in) :: var_list
     type(model_t), pointer, intent(in) :: model, fallback_model
     type(os_data_t), intent(in) :: os_data
     type(beam_structure_t), intent(in) :: beam_structure
     type(process_t), intent(in), optional :: process
     type(string_t) :: lhapdf_file, lhapdf_dir, process_name
     integer :: lhapdf_member
     type(shower_settings_t) :: settings
     type(taudec_settings_t) :: taudec_settings
     call msg_message ("Simulate: activating parton shower")
     allocate (evt_shower_t :: evt)
     call settings%init (var_list)
     if (associated (model)) then
        call taudec_settings%init (var_list, model)
     else
        call taudec_settings%init (var_list, fallback_model)
     end if
     if (present (process)) then
        process_name = process%get_id ()
     else
        process_name = 'dispatch_testing'
     end if
     select type (evt)
     type is (evt_shower_t)
        call evt%init (fallback_model, os_data)
        lhapdf_member = &
             var_list%get_ival (var_str ("lhapdf_member"))
        if (LHAPDF6_AVAILABLE) then
           lhapdf_dir = &
                var_list%get_sval (var_str ("$lhapdf_dir"))
           lhapdf_file = &
                var_list%get_sval (var_str ("$lhapdf_file"))
           call lhapdf_initialize &
                (1, lhapdf_dir, lhapdf_file, lhapdf_member, evt%pdf_data%pdf)
        end if
        if (present (process))  call evt%pdf_data%setup ("Shower", &
             beam_structure, lhapdf_member, process%get_pdf_set ())
        select case (settings%method)
        case (PS_WHIZARD)
           allocate (shower_t :: evt%shower)
        case (PS_PYTHIA6)
           allocate (shower_pythia6_t :: evt%shower)
        case default
           call msg_fatal ('Shower: Method ' // &
             char (var_list%get_sval (var_str ("$shower_method"))) // &
             'not implemented!')
        end select
        call evt%shower%init (settings, taudec_settings, evt%pdf_data)
     end select
     call dispatch_matching (evt, settings, var_list, process_name)
   end subroutine dispatch_evt_shower
 
 @ %def dispatch_evt_shower
 @
 <<Dispatch transforms: public>>=
   public :: dispatch_evt_shower_hook
 <<Dispatch transforms: procedures>>=
   subroutine dispatch_evt_shower_hook (hook, var_list, process_instance)
     class(process_instance_hook_t), pointer, intent(out) :: hook
     type(var_list_t), intent(in) :: var_list
     class(process_instance_t), intent(in), target :: process_instance
     if (var_list%get_lval (var_str ('?powheg_matching'))) then
        call msg_message ("Integration hook: add POWHEG hook")
        allocate (powheg_matching_hook_t :: hook)
        call hook%init (var_list, process_instance)
     else
        hook => null ()
     end if
   end subroutine dispatch_evt_shower_hook
 
 @ %def dispatch_evt_shower_hook
 @
 <<Dispatch transforms: public>>=
   public :: dispatch_matching
 <<Dispatch transforms: procedures>>=
   subroutine dispatch_matching (evt, settings, var_list, process_name)
     class(evt_t), intent(inout) :: evt
     type(var_list_t), intent(in) :: var_list
     type(string_t), intent(in) :: process_name
     type(shower_settings_t), intent(in) :: settings
     select type (evt)
     type is (evt_shower_t)
        if (settings%mlm_matching .and. settings%ckkw_matching) then
           call msg_fatal ("Both MLM and CKKW matching activated," // &
                LF // "     aborting simulation")
        end if
        if (settings%powheg_matching) then
           call msg_message ("Simulate: applying POWHEG matching")
           allocate (powheg_matching_t :: evt%matching)
        end if
        if (settings%mlm_matching) then
           call msg_message ("Simulate: applying MLM matching")
           allocate (mlm_matching_t :: evt%matching)
        end if
        if (settings%ckkw_matching) then
           call msg_warning ("Simulate: CKKW(-L) matching not yet supported")
           allocate (ckkw_matching_t :: evt%matching)
        end if
        if (allocated (evt%matching)) &
             call evt%matching%init (var_list, process_name)
     end select
   end subroutine dispatch_matching
 
 @ %def dispatch_matching
 @
 <<Dispatch transforms: public>>=
   public :: dispatch_evt_hadrons
 <<Dispatch transforms: procedures>>=
   subroutine dispatch_evt_hadrons (evt, var_list, fallback_model)
     class(evt_t), intent(out), pointer :: evt
     type(var_list_t), intent(in) :: var_list
     type(model_t), pointer, intent(in) :: fallback_model
     type(shower_settings_t) :: shower_settings
     type(hadron_settings_t) :: hadron_settings
     allocate (evt_hadrons_t :: evt)
     call msg_message ("Simulate: activating hadronization")
     call shower_settings%init (var_list)
     call hadron_settings%init (var_list)
     select type (evt)
     type is (evt_hadrons_t)
        call evt%init (fallback_model)
        select case (hadron_settings%method)
        case (HADRONS_WHIZARD)
           allocate (hadrons_hadrons_t :: evt%hadrons)
        case (HADRONS_PYTHIA6)
           allocate (hadrons_pythia6_t :: evt%hadrons)
        case (HADRONS_PYTHIA8)
           allocate (hadrons_pythia8_t :: evt%hadrons)
        case default
           call msg_fatal ('Hadronization: Method ' // &
             char (var_list%get_sval (var_str ("hadronization_method"))) // &
             'not implemented!')
        end select
        call evt%hadrons%init &
             (shower_settings, hadron_settings, fallback_model)
     end select
   end subroutine dispatch_evt_hadrons
 
 @ %def dispatch_evt_hadrons
 @ We cannot put this in the [[events]] subdir due to [[eio_raw_t]],
 which is defined here.
 <<Dispatch transforms: public>>=
   public :: dispatch_eio
 <<Dispatch transforms: procedures>>=
   subroutine dispatch_eio (eio, method, var_list, fallback_model, &
          event_callback)
     class(eio_t), allocatable, intent(inout) :: eio
     type(string_t), intent(in) :: method
     type(var_list_t), intent(in) :: var_list
     type(model_t), target, intent(in) :: fallback_model
     class(event_callback_t), allocatable, intent(in) :: event_callback
     !!! !!! !!! Workaround for ifort v18(beta) bug
     type(event_callback_nop_t) :: event_callback_tmp
     logical :: check, keep_beams, keep_remnants, recover_beams
     logical :: use_alphas_from_file, use_scale_from_file
     logical :: write_sqme_prc, write_sqme_ref, write_sqme_alt
     logical :: output_cross_section, ensure_order
     type(string_t) :: lhef_version, lhef_extension, raw_version
     type(string_t) :: extension_default, debug_extension, dump_extension, &
          extension_hepmc, &
          extension_lha, extension_hepevt, extension_ascii_short, &
          extension_ascii_long, extension_athena, extension_mokka, &
          extension_stdhep, extension_stdhep_up, extension_stdhep_ev4, &
          extension_raw, extension_hepevt_verb, extension_lha_verb, &
          extension_lcio
     integer :: checkpoint
     logical :: show_process, show_transforms, show_decay, verbose, pacified
     logical :: dump_weights, dump_compressed, dump_summary, dump_screen
     keep_beams = &
          var_list%get_lval (var_str ("?keep_beams"))
     keep_remnants = &
          var_list%get_lval (var_str ("?keep_remnants"))
     ensure_order = &
          var_list%get_lval (var_str ("?hepevt_ensure_order"))
     recover_beams = &
          var_list%get_lval (var_str ("?recover_beams"))
     use_alphas_from_file = &
          var_list%get_lval (var_str ("?use_alphas_from_file"))
     use_scale_from_file = &
          var_list%get_lval (var_str ("?use_scale_from_file"))
     select case (char (method))
     case ("raw")
        allocate (eio_raw_t :: eio)
        select type (eio)
        type is (eio_raw_t)
           check = &
                var_list%get_lval (var_str ("?check_event_file"))
           raw_version = &
                var_list%get_sval (var_str ("$event_file_version"))
           extension_raw = &
                var_list%get_sval (var_str ("$extension_raw"))
           call eio%set_parameters (check, raw_version, extension_raw)
        end select
     case ("checkpoint")
        allocate (eio_checkpoints_t :: eio)
        select type (eio)
        type is (eio_checkpoints_t)
           checkpoint = &
                var_list%get_ival (var_str ("checkpoint"))
           pacified = &
                var_list%get_lval (var_str ("?pacify"))
           call eio%set_parameters (checkpoint, blank = pacified)
        end select
     case ("callback")
        allocate (eio_callback_t :: eio)
        select type (eio)
        type is (eio_callback_t)
           checkpoint = &
                var_list%get_ival (var_str ("event_callback_interval"))
           if (allocated (event_callback)) then
              call eio%set_parameters (event_callback, checkpoint)
           else
              !!! !!! !!! Workaround for ifort v18(beta) bug
              ! call eio%set_parameters (event_callback_nop_t (), 0)
              call eio%set_parameters (event_callback_tmp, 0)
           end if
        end select
     case ("lhef")
        allocate (eio_lhef_t :: eio)
        select type (eio)
        type is (eio_lhef_t)
           lhef_version = &
                var_list%get_sval (var_str ("$lhef_version"))
           lhef_extension = &
                var_list%get_sval (var_str ("$lhef_extension"))
           write_sqme_prc = &
                var_list%get_lval (var_str ("?lhef_write_sqme_prc"))
           write_sqme_ref = &
                var_list%get_lval (var_str ("?lhef_write_sqme_ref"))
           write_sqme_alt = &
                var_list%get_lval (var_str ("?lhef_write_sqme_alt"))
           call eio%set_parameters ( &
                keep_beams, keep_remnants, recover_beams, &
                use_alphas_from_file, use_scale_from_file, &
                char (lhef_version), lhef_extension, &
                write_sqme_ref, write_sqme_prc, write_sqme_alt)
        end select
     case ("hepmc")
        allocate (eio_hepmc_t :: eio)
        select type (eio)
        type is (eio_hepmc_t)
           output_cross_section = &
                var_list%get_lval (var_str ("?hepmc_output_cross_section"))
           extension_hepmc = &
                var_list%get_sval (var_str ("$extension_hepmc"))
           call eio%set_parameters (recover_beams, &
                use_alphas_from_file, use_scale_from_file, &
                extension_hepmc, output_cross_section)
        end select
     case ("lcio")
        allocate (eio_lcio_t :: eio)
        select type (eio)
        type is (eio_lcio_t)
           extension_lcio = &
                var_list%get_sval (var_str ("$extension_lcio"))
           call eio%set_parameters (recover_beams, &
                use_alphas_from_file, use_scale_from_file, &
                extension_lcio)
        end select
     case ("stdhep")
        allocate (eio_stdhep_hepevt_t :: eio)
        select type (eio)
        type is (eio_stdhep_hepevt_t)
           extension_stdhep = &
                var_list%get_sval (var_str ("$extension_stdhep"))
           call eio%set_parameters &
                (keep_beams, keep_remnants, ensure_order, recover_beams, &
                 use_alphas_from_file, use_scale_from_file, extension_stdhep)
        end select
     case ("stdhep_up")
        allocate (eio_stdhep_hepeup_t :: eio)
        select type (eio)
        type is (eio_stdhep_hepeup_t)
           extension_stdhep_up = &
                var_list%get_sval (var_str ("$extension_stdhep_up"))
           call eio%set_parameters (keep_beams, keep_remnants, ensure_order, &
                recover_beams, use_alphas_from_file, &
                use_scale_from_file, extension_stdhep_up)
        end select
     case ("stdhep_ev4")
        allocate (eio_stdhep_hepev4_t :: eio)
        select type (eio)
        type is (eio_stdhep_hepev4_t)
           extension_stdhep_ev4 = &
                var_list%get_sval (var_str ("$extension_stdhep_ev4"))
           call eio%set_parameters &
                (keep_beams, keep_remnants, ensure_order, recover_beams, &
                 use_alphas_from_file, use_scale_from_file, extension_stdhep_ev4)
        end select
     case ("ascii")
        allocate (eio_ascii_ascii_t :: eio)
        select type (eio)
        type is (eio_ascii_ascii_t)
           extension_default = &
                var_list%get_sval (var_str ("$extension_default"))
           call eio%set_parameters &
                (keep_beams, keep_remnants, ensure_order, extension_default)
        end select
     case ("athena")
        allocate (eio_ascii_athena_t :: eio)
        select type (eio)
        type is (eio_ascii_athena_t)
           extension_athena = &
                var_list%get_sval (var_str ("$extension_athena"))
           call eio%set_parameters &
                (keep_beams, keep_remnants, ensure_order, extension_athena)
        end select
     case ("debug")
        allocate (eio_ascii_debug_t :: eio)
        select type (eio)
        type is (eio_ascii_debug_t)
           debug_extension = &
                var_list%get_sval (var_str ("$debug_extension"))
           show_process = &
                var_list%get_lval (var_str ("?debug_process"))
           show_transforms = &
                var_list%get_lval (var_str ("?debug_transforms"))
           show_decay = &
                var_list%get_lval (var_str ("?debug_decay"))
           verbose = &
                var_list%get_lval (var_str ("?debug_verbose"))
           call eio%set_parameters ( &
                extension = debug_extension, &
                show_process = show_process, &
                show_transforms = show_transforms, &
                show_decay = show_decay, &
                verbose = verbose)
        end select
     case ("dump")
        allocate (eio_dump_t :: eio)
        select type (eio)
        type is (eio_dump_t)
           dump_extension = &
                var_list%get_sval (var_str ("$dump_extension"))
           pacified = &
                var_list%get_lval (var_str ("?pacify"))
           dump_weights = &
                var_list%get_lval (var_str ("?dump_weights"))
           dump_compressed = &
                var_list%get_lval (var_str ("?dump_compressed"))
           dump_summary = &
                var_list%get_lval (var_str ("?dump_summary"))
           dump_screen = &
                var_list%get_lval (var_str ("?dump_screen"))
           call eio%set_parameters ( &
                extension = dump_extension, &
                pacify = pacified, &
                weights = dump_weights, &
                compressed = dump_compressed, &
                summary = dump_summary, &
                screen = dump_screen)
        end select
     case ("hepevt")
        allocate (eio_ascii_hepevt_t :: eio)
        select type (eio)
        type is (eio_ascii_hepevt_t)
           extension_hepevt = &
                var_list%get_sval (var_str ("$extension_hepevt"))
           call eio%set_parameters &
                (keep_beams, keep_remnants, ensure_order, extension_hepevt)
        end select
     case ("hepevt_verb")
        allocate (eio_ascii_hepevt_verb_t :: eio)
        select type (eio)
        type is (eio_ascii_hepevt_verb_t)
           extension_hepevt_verb = &
                var_list%get_sval (var_str ("$extension_hepevt_verb"))
           call eio%set_parameters &
                (keep_beams, keep_remnants, ensure_order, extension_hepevt_verb)
        end select
     case ("lha")
        allocate (eio_ascii_lha_t :: eio)
        select type (eio)
        type is (eio_ascii_lha_t)
           extension_lha = &
                var_list%get_sval (var_str ("$extension_lha"))
           call eio%set_parameters &
                (keep_beams, keep_remnants, ensure_order, extension_lha)
        end select
     case ("lha_verb")
        allocate (eio_ascii_lha_verb_t :: eio)
        select type (eio)
        type is (eio_ascii_lha_verb_t)
           extension_lha_verb = var_list%get_sval ( &
                var_str ("$extension_lha_verb"))
           call eio%set_parameters &
                (keep_beams, keep_remnants, ensure_order, extension_lha_verb)
        end select
     case ("long")
        allocate (eio_ascii_long_t :: eio)
        select type (eio)
        type is (eio_ascii_long_t)
           extension_ascii_long = &
                var_list%get_sval (var_str ("$extension_ascii_long"))
           call eio%set_parameters &
                (keep_beams, keep_remnants, ensure_order, extension_ascii_long)
        end select
     case ("mokka")
        allocate (eio_ascii_mokka_t :: eio)
        select type (eio)
        type is (eio_ascii_mokka_t)
           extension_mokka = &
                var_list%get_sval (var_str ("$extension_mokka"))
           call eio%set_parameters &
                (keep_beams, keep_remnants, ensure_order, extension_mokka)
        end select
     case ("short")
        allocate (eio_ascii_short_t :: eio)
        select type (eio)
        type is (eio_ascii_short_t)
           extension_ascii_short = &
                var_list%get_sval (var_str ("$extension_ascii_short"))
           call eio%set_parameters &
                (keep_beams, keep_remnants, ensure_order, extension_ascii_short)
        end select
     case ("weight_stream")
        allocate (eio_weights_t :: eio)
        select type (eio)
        type is (eio_weights_t)
           pacified = &
                var_list%get_lval (var_str ("?pacify"))
           call eio%set_parameters (pacify = pacified)
        end select
     case default
        call msg_fatal ("Event I/O method '" // char (method) &
             // "' not implemented")
     end select
     call eio%set_fallback_model (fallback_model)
   end subroutine dispatch_eio
 
 @ %def dispatch_eio
 @
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[dispatch_transforms_ut.f90]]>>=
 <<File header>>
 
 module dispatch_transforms_ut
   use unit_tests
   use dispatch_transforms_uti
 
 <<Standard module head>>
 
 <<Dispatch transforms: public test>>
 
 contains
 
 <<Dispatch transforms: test driver>>
 
 end module dispatch_transforms_ut
 @ %def dispatch_transforms_ut
 @
 <<[[dispatch_transforms_uti.f90]]>>=
 <<File header>>
 
 module dispatch_transforms_uti
 
 <<Use kinds>>
 <<Use strings>>
   use format_utils, only: write_separator
   use variables
   use event_base, only: event_callback_t
   use models, only: model_t, model_list_t
   use models, only: syntax_model_file_init, syntax_model_file_final
   use resonances, only: resonance_history_set_t
   use beam_structures, only: beam_structure_t
   use eio_base, only: eio_t
   use os_interface, only: os_data_t, os_data_init
   use event_transforms, only: evt_t
   use dispatch_transforms
 
 <<Standard module head>>
 
 <<Dispatch transforms: test declarations>>
 
 contains
 
 <<Dispatch transforms: tests>>
 
 end module dispatch_transforms_uti
 @ %def dispatch_transforms_uti
 @ API: driver for the unit tests below.
 <<Dispatch transforms: public test>>=
   public ::dispatch_transforms_test
 <<Dispatch transforms: test driver>>=
   subroutine dispatch_transforms_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Dispatch transforms: execute tests>>
   end subroutine dispatch_transforms_test
 
 @  %def dispatch_transforms_test
 @
 \subsubsection{Event I/O}
 <<Dispatch transforms: execute tests>>=
   call test (dispatch_transforms_1, "dispatch_transforms_1", &
        "event I/O", &
        u, results)
 <<Dispatch transforms: test declarations>>=
   public :: dispatch_transforms_1
 <<Dispatch transforms: tests>>=
   subroutine dispatch_transforms_1 (u)
     integer, intent(in) :: u
     type(var_list_t) :: var_list
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(os_data_t) :: os_data
     class(event_callback_t), allocatable :: event_callback
     class(eio_t), allocatable :: eio
 
     write (u, "(A)")  "* Test output: dispatch_transforms_1"
     write (u, "(A)")  "*   Purpose: allocate an event I/O (eio) stream"
     write (u, "(A)")
 
     call var_list%init_defaults (0)
     call os_data_init (os_data)
     call syntax_model_file_init ()
     call model_list%read_model (var_str ("SM_hadrons"), &
          var_str ("SM_hadrons.mdl"), os_data, model)
 
     write (u, "(A)")  "* Allocate as raw"
     write (u, "(A)")
 
     call dispatch_eio (eio, var_str ("raw"), var_list, &
          model, event_callback)
 
     call eio%write (u)
 
     call eio%final ()
     deallocate (eio)
 
     write (u, "(A)")
     write (u, "(A)")  "* Allocate as checkpoints:"
     write (u, "(A)")
 
     call dispatch_eio (eio, var_str ("checkpoint"), var_list, &
          model, event_callback)
 
     call eio%write (u)
 
     call eio%final ()
     deallocate (eio)
 
     write (u, "(A)")
     write (u, "(A)")  "* Allocate as LHEF:"
     write (u, "(A)")
 
     call var_list%set_string (var_str ("$lhef_extension"), &
          var_str ("lhe_custom"), is_known = .true.)
     call dispatch_eio (eio, var_str ("lhef"), var_list, &
          model, event_callback)
 
     call eio%write (u)
 
     call eio%final ()
     deallocate (eio)
 
     write (u, "(A)")
     write (u, "(A)")  "* Allocate as HepMC:"
     write (u, "(A)")
 
     call dispatch_eio (eio, var_str ("hepmc"), var_list, &
          model, event_callback)
 
     call eio%write (u)
 
     call eio%final ()
     deallocate (eio)
 
     write (u, "(A)")
     write (u, "(A)")  "* Allocate as weight_stream"
     write (u, "(A)")
 
     call dispatch_eio (eio, var_str ("weight_stream"), var_list, &
          model, event_callback)
 
     call eio%write (u)
 
     call eio%final ()
     deallocate (eio)
 
     write (u, "(A)")
     write (u, "(A)")  "* Allocate as debug format"
     write (u, "(A)")
 
     call var_list%set_log (var_str ("?debug_verbose"), &
          .false., is_known = .true.)
     call dispatch_eio (eio, var_str ("debug"), var_list, &
          model, event_callback)
 
     call eio%write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call eio%final ()
     call var_list%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: dispatch_transforms_1"
 
   end subroutine dispatch_transforms_1
 
 @ %def dispatch_transforms_1
 @
 \subsubsection{Event transforms}
 This test dispatches [[evt]] (event transform) objects.
 <<Dispatch transforms: execute tests>>=
   call test (dispatch_transforms_2, "dispatch_transforms_2", &
        "event transforms", &
        u, results)
 <<Dispatch transforms: test declarations>>=
   public :: dispatch_transforms_2
 <<Dispatch transforms: tests>>=
   subroutine dispatch_transforms_2 (u)
     integer, intent(in) :: u
     type(var_list_t), target :: var_list
     type(model_list_t) :: model_list
     type(model_t), pointer :: model
     type(os_data_t) :: os_data
     type(resonance_history_set_t), dimension(1) :: res_history_set
     type(beam_structure_t) :: beam_structure
     class(evt_t), pointer :: evt
 
     write (u, "(A)")  "* Test output: dispatch_transforms_2"
     write (u, "(A)")  "*   Purpose: configure event transform"
     write (u, "(A)")
 
     call syntax_model_file_init ()
     call var_list%init_defaults (0)
     call os_data_init (os_data)
     call model_list%read_model (var_str ("SM_hadrons"), &
          var_str ("SM_hadrons.mdl"), os_data, model)
 
     write (u, "(A)")  "* Resonance insertion"
     write (u, "(A)")
 
     call var_list%set_log (var_str ("?resonance_history"), .true., &
          is_known = .true.)
     call dispatch_evt_resonance (evt, var_list, &
          res_history_set, &
          var_str ("foo_R"))
     call evt%write (u, verbose = .true., more_verbose = .true.)
 
     call evt%final ()
     deallocate (evt)
 
     write (u, "(A)")
     write (u, "(A)")  "* ISR handler"
     write (u, "(A)")
 
     call var_list%set_log (var_str ("?isr_handler"), .true., &
          is_known = .true.)
     call var_list%set_log (var_str ("?epa_handler"), .false., &
          is_known = .true.)
     call var_list%set_string (var_str ("$isr_handler_mode"), &
          var_str ("recoil"), &
          is_known = .true.)
     call var_list%set_real (var_str ("sqrts"), 100._default, &
          is_known = .true.)
     call var_list%set_real (var_str ("isr_mass"), 511.e-6_default, &
          is_known = .true.)
     call dispatch_evt_isr_epa_handler (evt, var_list)
     call evt%write (u, verbose = .true., more_verbose = .true.)
 
     call evt%final ()
     deallocate (evt)
 
     write (u, "(A)")
     write (u, "(A)")  "* EPA handler"
     write (u, "(A)")
 
     call var_list%set_log (var_str ("?isr_handler"), .false., &
          is_known = .true.)
     call var_list%set_log (var_str ("?epa_handler"), .true., &
          is_known = .true.)
     call var_list%set_string (var_str ("$epa_handler_mode"), &
          var_str ("recoil"), &
          is_known = .true.)
     call var_list%set_real (var_str ("sqrts"), 100._default, &
          is_known = .true.)
     call var_list%set_real (var_str ("epa_mass"), 511.e-6_default, &
          is_known = .true.)
     call dispatch_evt_isr_epa_handler (evt, var_list)
     call evt%write (u, verbose = .true., more_verbose = .true.)
 
     call evt%final ()
     deallocate (evt)
 
     write (u, "(A)")
     write (u, "(A)")  "* Partonic decays"
     write (u, "(A)")
 
     call dispatch_evt_decay (evt, var_list)
     call evt%write (u, verbose = .true., more_verbose = .true.)
 
     call evt%final ()
     deallocate (evt)
 
     write (u, "(A)")
     write (u, "(A)")  "* Shower"
     write (u, "(A)")
 
     call var_list%set_log (var_str ("?allow_shower"), .true., &
          is_known = .true.)
     call var_list%set_string (var_str ("$shower_method"), &
          var_str ("WHIZARD"), is_known = .true.)
     call dispatch_evt_shower (evt, var_list, model, &
          model, os_data, beam_structure)
     call evt%write (u)
     call write_separator (u, 2)
 
     call evt%final ()
     deallocate (evt)
 
     call var_list%final ()
     call syntax_model_file_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: dispatch_transforms_2"
 
   end subroutine dispatch_transforms_2
 
 @ %def dispatch_transforms_2
Index: trunk/src/types/types.nw
===================================================================
--- trunk/src/types/types.nw	(revision 8163)
+++ trunk/src/types/types.nw	(revision 8164)
@@ -1,7715 +1,7842 @@
 %% -*- ess-noweb-default-code-mode: f90-mode; noweb-default-code-mode: f90-mode; -*-
 % WHIZARD code as NOWEB source: common types and objects
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Sindarin Built-In Types}
 \includemodulegraph{types}
 
 Here, we define a couple of types and objects which are useful both
 internally for \whizard, and visible to the user, so they correspond
 to Sindarin types.
 \begin{description}
 \item[particle\_specifiers]
   Expressions for particles and particle alternatives, involving
   particle names.
 \item[pdg\_arrays]
   Integer (PDG) codes for particles.  Useful for particle aliases
   (e.g., 'quark' for $u,d,s$ etc.).
 \item[jets]
   Define (pseudo)jets as objects.  Functional only if the [[fastjet]] library
   is linked.  (This may change in the future.)
 \item[subevents]
   Particle collections built from event records, for use in analysis and other
   Sindarin expressions
 \item[analysis]
   Observables, histograms, and plots.
 \end{description}
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Particle Specifiers}
 In this module we introduce a type for specifying a particle or particle
 alternative.  In addition to the particle specifiers (strings separated by
 colons), the type contains an optional flag [[polarized]] and a string
 [[decay]].  If the [[polarized]] flag is set, particle polarization
 information should be kept when generating events for this process.  If the
 [[decay]] string is set, it is the ID of a decay process which should be
 applied to this particle when generating events.
 
 In input/output form, the [[polarized]] flag is indicated by an asterisk
 [[(*)]] in brackets, and the [[decay]] is indicated by its ID in brackets.
 
 The [[read]] and [[write]] procedures in this module are not type-bound but
 generic procedures which handle scalar and array arguments.
 <<[[particle_specifiers.f90]]>>=
 <<File header>>
 
 module particle_specifiers
 
 <<Use strings>>
   use io_units
   use diagnostics
 
 <<Standard module head>>
 
 <<Particle specifiers: public>>
 
 <<Particle specifiers: types>>
 
 <<Particle specifiers: interfaces>>
 
 contains
 
 <<Particle specifiers: procedures>>
 
 end module particle_specifiers
 @ %def particle_specifiers
 @
 \subsection{Base type}
 This is an abstract type which can hold a single particle or an expression.
 <<Particle specifiers: types>>=
   type, abstract :: prt_spec_expr_t
    contains
    <<Particle specifiers: prt spec expr: TBP>>
   end type prt_spec_expr_t
 
 @ %def prt_expr_t
 @ Output, as a string.
 <<Particle specifiers: prt spec expr: TBP>>=
   procedure (prt_spec_expr_to_string), deferred :: to_string
 <<Particle specifiers: interfaces>>=
   abstract interface
      function prt_spec_expr_to_string (object) result (string)
        import
        class(prt_spec_expr_t), intent(in) :: object
        type(string_t) :: string
      end function prt_spec_expr_to_string
   end interface
 
 @ %def prt_spec_expr_to_string
 @ Call an [[expand]] method for all enclosed subexpressions (before handling
 the current expression).
 <<Particle specifiers: prt spec expr: TBP>>=
   procedure (prt_spec_expr_expand_sub), deferred :: expand_sub
 <<Particle specifiers: interfaces>>=
   abstract interface
      subroutine prt_spec_expr_expand_sub (object)
        import
        class(prt_spec_expr_t), intent(inout) :: object
      end subroutine prt_spec_expr_expand_sub
   end interface
 
 @ %def prt_spec_expr_expand_sub
 @
 \subsection{Wrapper type}
 This wrapper can hold a particle expression of any kind.  We need it so we can
 make variadic arrays.
 <<Particle specifiers: public>>=
   public :: prt_expr_t
 <<Particle specifiers: types>>=
   type :: prt_expr_t
      class(prt_spec_expr_t), allocatable :: x
    contains
    <<Particle specifiers: prt expr: TBP>>
   end type prt_expr_t
 
 @ %def prt_expr_t
 @ Output as a string: delegate.
 <<Particle specifiers: prt expr: TBP>>=
   procedure :: to_string => prt_expr_to_string
 <<Particle specifiers: procedures>>=
   recursive function prt_expr_to_string (object) result (string)
     class(prt_expr_t), intent(in) :: object
     type(string_t) :: string
     if (allocated (object%x)) then
        string = object%x%to_string ()
     else
        string = ""
     end if
   end function prt_expr_to_string
 
 @ %def prt_expr_to_string
 @ Allocate the expression as a particle specifier and copy the value.
 <<Particle specifiers: prt expr: TBP>>=
   procedure :: init_spec => prt_expr_init_spec
 <<Particle specifiers: procedures>>=
   subroutine prt_expr_init_spec (object, spec)
     class(prt_expr_t), intent(out) :: object
     type(prt_spec_t), intent(in) :: spec
     allocate (prt_spec_t :: object%x)
     select type (x => object%x)
     type is (prt_spec_t)
        x = spec
     end select
   end subroutine prt_expr_init_spec
 
 @ %def prt_expr_init_spec
 @ Allocate as a list/sum and allocate for a given length
 <<Particle specifiers: prt expr: TBP>>=
   procedure :: init_list => prt_expr_init_list
   procedure :: init_sum => prt_expr_init_sum
 <<Particle specifiers: procedures>>=
   subroutine prt_expr_init_list (object, n)
     class(prt_expr_t), intent(out) :: object
     integer, intent(in) :: n
     allocate (prt_spec_list_t :: object%x)
     select type (x => object%x)
     type is (prt_spec_list_t)
        allocate (x%expr (n))
     end select
   end subroutine prt_expr_init_list
 
   subroutine prt_expr_init_sum (object, n)
     class(prt_expr_t), intent(out) :: object
     integer, intent(in) :: n
     allocate (prt_spec_sum_t :: object%x)
     select type (x => object%x)
     type is (prt_spec_sum_t)
        allocate (x%expr (n))
     end select
   end subroutine prt_expr_init_sum
 
 @ %def prt_expr_init_list
 @ %def prt_expr_init_sum
 @ Return the number of terms.  This is unity, except if the expression is a
 sum.
 <<Particle specifiers: prt expr: TBP>>=
   procedure :: get_n_terms => prt_expr_get_n_terms
 <<Particle specifiers: procedures>>=
   function prt_expr_get_n_terms (object) result (n)
     class(prt_expr_t), intent(in) :: object
     integer :: n
     if (allocated (object%x)) then
        select type (x => object%x)
        type is (prt_spec_sum_t)
           n = size (x%expr)
        class default
           n = 1
        end select
     else
        n = 0
     end if
   end function prt_expr_get_n_terms
 
 @ %def prt_expr_get_n_terms
 @ Transform one of the terms, as returned by the previous method, to an array
 of particle specifiers.  The array has more than one entry if the selected
 term is a list.  This makes sense only if the expression has been completely
 expanded, so the list contains only atoms.
 <<Particle specifiers: prt expr: TBP>>=
   procedure :: term_to_array => prt_expr_term_to_array
 <<Particle specifiers: procedures>>=
   recursive subroutine prt_expr_term_to_array (object, array, i)
     class(prt_expr_t), intent(in) :: object
     type(prt_spec_t), dimension(:), intent(inout), allocatable :: array
     integer, intent(in) :: i
     integer :: j
     if (allocated (array))  deallocate (array)
     select type (x => object%x)
     type is (prt_spec_t)
        allocate (array (1))
        array(1) = x
     type is (prt_spec_list_t)
        allocate (array (size (x%expr)))
        do j = 1, size (array)
           select type (y => x%expr(j)%x)
           type is (prt_spec_t)
              array(j) = y
           end select
        end do
     type is (prt_spec_sum_t)
        call x%expr(i)%term_to_array (array, 1)
     end select
   end subroutine prt_expr_term_to_array
 
 @ %def prt_expr_term_to_array
 @
 \subsection{The atomic type}
 The trivial case is a single particle, including optional decay and
 polarization attributes.
 
 \subsubsection{Definition}
 The particle is unstable if the [[decay]] array is allocated.  The
 [[polarized]] flag and decays may not be set simultaneously.
 <<Particle specifiers: public>>=
   public :: prt_spec_t
 <<Particle specifiers: types>>=
   type, extends (prt_spec_expr_t) :: prt_spec_t
      private
      type(string_t) :: name
      logical :: polarized = .false.
      type(string_t), dimension(:), allocatable :: decay
    contains
    <<Particle specifiers: prt spec: TBP>>
   end type prt_spec_t
 
 @ %def prt_spec_t
 @
 \subsubsection{I/O}
 Output.  Old-style subroutines.
 <<Particle specifiers: public>>=
   public :: prt_spec_write
 <<Particle specifiers: interfaces>>=
   interface prt_spec_write
      module procedure prt_spec_write1
      module procedure prt_spec_write2
   end interface prt_spec_write
 <<Particle specifiers: procedures>>=
   subroutine prt_spec_write1 (object, unit, advance)
     type(prt_spec_t), intent(in) :: object
     integer, intent(in), optional :: unit
     character(len=*), intent(in), optional :: advance
     character(3) :: adv
     integer :: u
     u = given_output_unit (unit)
     adv = "yes";  if (present (advance))  adv = advance
     write (u, "(A)", advance = adv)  char (object%to_string ())
   end subroutine prt_spec_write1
 
 @ %def prt_spec_write1
 @ Write an array as a list of particle specifiers.
 <<Particle specifiers: procedures>>=
   subroutine prt_spec_write2 (prt_spec, unit, advance)
     type(prt_spec_t), dimension(:), intent(in) :: prt_spec
     integer, intent(in), optional :: unit
     character(len=*), intent(in), optional :: advance
     character(3) :: adv
     integer :: u, i
     u = given_output_unit (unit)
     adv = "yes";  if (present (advance))  adv = advance
     do i = 1, size (prt_spec)
        if (i > 1)  write (u, "(A)", advance="no")  ", "
        call prt_spec_write (prt_spec(i), u, advance="no")
     end do
     write (u, "(A)", advance = adv)
   end subroutine prt_spec_write2
 
 @ %def prt_spec_write2
 @ Read.  Input may be string or array of strings.
 <<Particle specifiers: public>>=
   public :: prt_spec_read
 <<Particle specifiers: interfaces>>=
   interface prt_spec_read
      module procedure prt_spec_read1
      module procedure prt_spec_read2
   end interface prt_spec_read
 @ Read a single particle specifier
 <<Particle specifiers: procedures>>=
   pure subroutine prt_spec_read1 (prt_spec, string)
     type(prt_spec_t), intent(out) :: prt_spec
     type(string_t), intent(in) :: string
     type(string_t) :: arg, buffer
     integer :: b1, b2, c, n, i
     b1 = scan (string, "(")
     b2 = scan (string, ")")
     if (b1 == 0) then
        prt_spec%name = trim (adjustl (string))
     else
        prt_spec%name = trim (adjustl (extract (string, 1, b1-1)))
        arg = trim (adjustl (extract (string, b1+1, b2-1)))
        if (arg == "*") then
           prt_spec%polarized = .true.
        else
           n = 0
           buffer = arg
           do
              if (verify (buffer, " ") == 0)  exit
              n = n + 1
              c = scan (buffer, "+")
              if (c == 0)  exit
              buffer = extract (buffer, c+1)
           end do
           allocate (prt_spec%decay (n))
           buffer = arg
           do i = 1, n
              c = scan (buffer, "+")
              if (c == 0)  c = len (buffer) + 1
              prt_spec%decay(i) = trim (adjustl (extract (buffer, 1, c-1)))
              buffer = extract (buffer, c+1)
           end do
        end if
     end if
   end subroutine prt_spec_read1
 
 @ %def prt_spec_read1
 @ Read a particle specifier array, given as a single string.  The
 array is allocated to the correct size.
 <<Particle specifiers: procedures>>=
   pure subroutine prt_spec_read2 (prt_spec, string)
     type(prt_spec_t), dimension(:), intent(out), allocatable :: prt_spec
     type(string_t), intent(in) :: string
     type(string_t) :: buffer
     integer :: c, i, n
     n = 0
     buffer = string
     do
        n = n + 1
        c = scan (buffer, ",")
        if (c == 0)  exit
        buffer = extract (buffer, c+1)
     end do
     allocate (prt_spec (n))
     buffer = string
     do i = 1, size (prt_spec)
        c = scan (buffer, ",")
        if (c == 0)  c = len (buffer) + 1
        call prt_spec_read (prt_spec(i), &
             trim (adjustl (extract (buffer, 1, c-1))))
        buffer = extract (buffer, c+1)
     end do
   end subroutine prt_spec_read2
 
 @ %def prt_spec_read2
 @
 \subsubsection{Constructor}
 Initialize a particle specifier.
 <<Particle specifiers: public>>=
   public :: new_prt_spec
 <<Particle specifiers: interfaces>>=
   interface new_prt_spec
      module procedure new_prt_spec
      module procedure new_prt_spec_polarized
      module procedure new_prt_spec_unstable
   end interface new_prt_spec
 <<Particle specifiers: procedures>>=
   elemental function new_prt_spec (name) result (prt_spec)
     type(string_t), intent(in) :: name
     type(prt_spec_t) :: prt_spec
     prt_spec%name = name
   end function new_prt_spec
 
   elemental function new_prt_spec_polarized (name, polarized) result (prt_spec)
     type(string_t), intent(in) :: name
     logical, intent(in) :: polarized
     type(prt_spec_t) :: prt_spec
     prt_spec%name = name
     prt_spec%polarized = polarized
   end function new_prt_spec_polarized
 
   pure function new_prt_spec_unstable (name, decay) result (prt_spec)
     type(string_t), intent(in) :: name
     type(string_t), dimension(:), intent(in) :: decay
     type(prt_spec_t) :: prt_spec
     prt_spec%name = name
     allocate (prt_spec%decay (size (decay)))
     prt_spec%decay = decay
   end function new_prt_spec_unstable
 
 @ %def new_prt_spec
 @
 \subsubsection{Access Methods}
 Return the particle name without qualifiers
 <<Particle specifiers: prt spec: TBP>>=
   procedure :: get_name => prt_spec_get_name
 <<Particle specifiers: procedures>>=
   elemental function prt_spec_get_name (prt_spec) result (name)
     class(prt_spec_t), intent(in) :: prt_spec
     type(string_t) :: name
     name = prt_spec%name
   end function prt_spec_get_name
 
 @ %def prt_spec_get_name
 @ Return the name with qualifiers
 <<Particle specifiers: prt spec: TBP>>=
   procedure :: to_string => prt_spec_to_string
 <<Particle specifiers: procedures>>=
   function prt_spec_to_string (object) result (string)
     class(prt_spec_t), intent(in) :: object
     type(string_t) :: string
     integer :: i
     string = object%name
     if (allocated (object%decay)) then
        string = string // "("
        do i = 1, size (object%decay)
           if (i > 1)  string = string // " + "
           string = string // object%decay(i)
        end do
        string = string // ")"
     else if (object%polarized) then
        string = string // "(*)"
     end if
   end function prt_spec_to_string
 
 @ %def prt_spec_to_string
 @ Return the polarization flag
 <<Particle specifiers: prt spec: TBP>>=
   procedure :: is_polarized => prt_spec_is_polarized
 <<Particle specifiers: procedures>>=
   elemental function prt_spec_is_polarized (prt_spec) result (flag)
     class(prt_spec_t), intent(in) :: prt_spec
     logical :: flag
     flag = prt_spec%polarized
   end function prt_spec_is_polarized
 
 @ %def prt_spec_is_polarized
 @ The particle is unstable if there is a decay array.
 <<Particle specifiers: prt spec: TBP>>=
   procedure :: is_unstable => prt_spec_is_unstable
 <<Particle specifiers: procedures>>=
   elemental function prt_spec_is_unstable (prt_spec) result (flag)
     class(prt_spec_t), intent(in) :: prt_spec
     logical :: flag
     flag = allocated (prt_spec%decay)
   end function prt_spec_is_unstable
 
 @ %def prt_spec_is_unstable
 @ Return the number of decay channels
 <<Particle specifiers: prt spec: TBP>>=
   procedure :: get_n_decays => prt_spec_get_n_decays
 <<Particle specifiers: procedures>>=
   elemental function prt_spec_get_n_decays (prt_spec) result (n)
     class(prt_spec_t), intent(in) :: prt_spec
     integer :: n
     if (allocated (prt_spec%decay)) then
        n = size (prt_spec%decay)
     else
        n = 0
     end if
   end function prt_spec_get_n_decays
 
 @ %def prt_spec_get_n_decays
 @ Return the decay channels
 <<Particle specifiers: prt spec: TBP>>=
   procedure :: get_decays => prt_spec_get_decays
 <<Particle specifiers: procedures>>=
   subroutine prt_spec_get_decays (prt_spec, decay)
     class(prt_spec_t), intent(in) :: prt_spec
     type(string_t), dimension(:), allocatable, intent(out) :: decay
     if (allocated (prt_spec%decay)) then
        allocate (decay (size (prt_spec%decay)))
        decay = prt_spec%decay
     else
        allocate (decay (0))
     end if
   end subroutine prt_spec_get_decays
 
 @ %def prt_spec_get_decays
 @
 \subsubsection{Miscellaneous}
 There is nothing to expand here:
 <<Particle specifiers: prt spec: TBP>>=
   procedure :: expand_sub => prt_spec_expand_sub
 <<Particle specifiers: procedures>>=
   subroutine prt_spec_expand_sub (object)
     class(prt_spec_t), intent(inout) :: object
   end subroutine prt_spec_expand_sub
 
 @ %def prt_spec_expand_sub
 @
 \subsection{List}
 A list of particle specifiers, indicating, e.g., the final state of a
 process.
 <<Particle specifiers: public>>=
   public :: prt_spec_list_t
 <<Particle specifiers: types>>=
   type, extends (prt_spec_expr_t) :: prt_spec_list_t
      type(prt_expr_t), dimension(:), allocatable :: expr
    contains
    <<Particle specifiers: prt spec list: TBP>>
   end type prt_spec_list_t
 
 @ %def prt_spec_list_t
 @ Output: Concatenate the components.  Insert brackets if the component is
 also a list.  The components of the [[expr]] array, if any, should all be
 filled.
 <<Particle specifiers: prt spec list: TBP>>=
   procedure :: to_string => prt_spec_list_to_string
 <<Particle specifiers: procedures>>=
   recursive function prt_spec_list_to_string (object) result (string)
     class(prt_spec_list_t), intent(in) :: object
     type(string_t) :: string
     integer :: i
     string = ""
     if (allocated (object%expr)) then
        do i = 1, size (object%expr)
           if (i > 1)  string = string // ", "
           select type (x => object%expr(i)%x)
           type is (prt_spec_list_t)
              string = string // "(" // x%to_string () // ")"
           class default
              string = string // x%to_string ()
           end select
        end do
     end if
   end function prt_spec_list_to_string
 
 @ %def prt_spec_list_to_string
 @ Flatten: if there is a subexpression which is also a list, include the
 components as direct members of the current list.
 <<Particle specifiers: prt spec list: TBP>>=
   procedure :: flatten => prt_spec_list_flatten
 <<Particle specifiers: procedures>>=
   subroutine prt_spec_list_flatten (object)
     class(prt_spec_list_t), intent(inout) :: object
     type(prt_expr_t), dimension(:), allocatable :: tmp_expr
     integer :: i, n_flat, i_flat
     n_flat = 0
     do i = 1, size (object%expr)
        select type (y => object%expr(i)%x)
        type is (prt_spec_list_t)
           n_flat = n_flat + size (y%expr)
        class default
           n_flat = n_flat + 1
        end select
     end do
     if (n_flat > size (object%expr)) then
        allocate (tmp_expr (n_flat))
        i_flat = 0
        do i = 1, size (object%expr)
           select type (y => object%expr(i)%x)
           type is (prt_spec_list_t)
              tmp_expr (i_flat + 1 : i_flat + size (y%expr)) = y%expr
              i_flat = i_flat + size (y%expr)
           class default
              tmp_expr (i_flat + 1) = object%expr(i)
              i_flat = i_flat + 1
           end select
        end do
     end if
     if (allocated (tmp_expr)) &
          call move_alloc (from = tmp_expr, to = object%expr)
   end subroutine prt_spec_list_flatten
 
 @ %def prt_spec_list_flatten
 @ Convert a list of sums into a sum of lists.  (Subexpressions which are not
 sums are left untouched.)
 <<Particle specifiers: procedures>>=
   subroutine distribute_prt_spec_list (object)
     class(prt_spec_expr_t), intent(inout), allocatable :: object
     class(prt_spec_expr_t), allocatable :: new_object
     integer, dimension(:), allocatable :: n, ii
     integer :: k, n_expr, n_terms, i_term
     select type (object)
     type is (prt_spec_list_t)
        n_expr = size (object%expr)
        allocate (n (n_expr), source = 1)
        allocate (ii (n_expr), source = 1)
        do k = 1, size (object%expr)
           select type (y => object%expr(k)%x)
           type is (prt_spec_sum_t)
              n(k) = size (y%expr)
           end select
        end do
        n_terms = product (n)
        if (n_terms > 1) then
           allocate (prt_spec_sum_t :: new_object)
           select type (new_object)
           type is (prt_spec_sum_t)
              allocate (new_object%expr (n_terms))
              do i_term = 1, n_terms
                 allocate (prt_spec_list_t :: new_object%expr(i_term)%x)
                 select type (x => new_object%expr(i_term)%x)
                 type is (prt_spec_list_t)
                    allocate (x%expr (n_expr))
                    do k = 1, n_expr
                       select type (y => object%expr(k)%x)
                       type is (prt_spec_sum_t)
                          x%expr(k) = y%expr(ii(k))
                       class default
                          x%expr(k) = object%expr(k)
                       end select
                    end do
                 end select
                 INCR_INDEX: do k = n_expr, 1, -1
                    if (ii(k) < n(k)) then
                       ii(k) = ii(k) + 1
                       exit INCR_INDEX
                    else
                       ii(k) = 1
                    end if
                 end do INCR_INDEX
              end do
           end select
        end if
     end select
     if (allocated (new_object)) call move_alloc (from = new_object, to = object)
   end subroutine distribute_prt_spec_list
 
 @ %def distribute_prt_spec_list
 @ Apply [[expand]] to all components of the list.
 <<Particle specifiers: prt spec list: TBP>>=
   procedure :: expand_sub => prt_spec_list_expand_sub
 <<Particle specifiers: procedures>>=
   recursive subroutine prt_spec_list_expand_sub (object)
     class(prt_spec_list_t), intent(inout) :: object
     integer :: i
     if (allocated (object%expr)) then
        do i = 1, size (object%expr)
           call object%expr(i)%expand ()
        end do
     end if
   end subroutine prt_spec_list_expand_sub
 
 @ %def prt_spec_list_expand_sub
 @
 \subsection{Sum}
 A sum of particle specifiers, indicating, e.g., a sum of final states.
 <<Particle specifiers: public>>=
   public :: prt_spec_sum_t
 <<Particle specifiers: types>>=
   type, extends (prt_spec_expr_t) :: prt_spec_sum_t
      type(prt_expr_t), dimension(:), allocatable :: expr
    contains
    <<Particle specifiers: prt spec sum: TBP>>
   end type prt_spec_sum_t
 
 @ %def prt_spec_sum_t
 @ Output: Concatenate the components.  Insert brackets if the component is
 a list or also a sum.  The components of the [[expr]] array, if any, should
 all be filled.
 <<Particle specifiers: prt spec sum: TBP>>=
   procedure :: to_string => prt_spec_sum_to_string
 <<Particle specifiers: procedures>>=
   recursive function prt_spec_sum_to_string (object) result (string)
     class(prt_spec_sum_t), intent(in) :: object
     type(string_t) :: string
     integer :: i
     string = ""
     if (allocated (object%expr)) then
        do i = 1, size (object%expr)
           if (i > 1)  string = string // " + "
           select type (x => object%expr(i)%x)
           type is (prt_spec_list_t)
              string = string // "(" // x%to_string () // ")"
           type is (prt_spec_sum_t)
              string = string // "(" // x%to_string () // ")"
           class default
              string = string // x%to_string ()
           end select
        end do
     end if
   end function prt_spec_sum_to_string
 
 @ %def prt_spec_sum_to_string
 @ Flatten: if there is a subexpression which is also a sum, include the
 components as direct members of the current sum.
 
 This is identical to [[prt_spec_list_flatten]] above, except for the type.
 <<Particle specifiers: prt spec sum: TBP>>=
   procedure :: flatten => prt_spec_sum_flatten
 <<Particle specifiers: procedures>>=
   subroutine prt_spec_sum_flatten (object)
     class(prt_spec_sum_t), intent(inout) :: object
     type(prt_expr_t), dimension(:), allocatable :: tmp_expr
     integer :: i, n_flat, i_flat
     n_flat = 0
     do i = 1, size (object%expr)
        select type (y => object%expr(i)%x)
        type is (prt_spec_sum_t)
           n_flat = n_flat + size (y%expr)
           class default
           n_flat = n_flat + 1
        end select
     end do
     if (n_flat > size (object%expr)) then
        allocate (tmp_expr (n_flat))
        i_flat = 0
        do i = 1, size (object%expr)
           select type (y => object%expr(i)%x)
           type is (prt_spec_sum_t)
              tmp_expr (i_flat + 1 : i_flat + size (y%expr)) = y%expr
              i_flat = i_flat + size (y%expr)
           class default
              tmp_expr (i_flat + 1) = object%expr(i)
              i_flat = i_flat + 1
           end select
        end do
     end if
     if (allocated (tmp_expr)) &
          call move_alloc (from = tmp_expr, to = object%expr)
   end subroutine prt_spec_sum_flatten
 
 @ %def prt_spec_sum_flatten
 @ Apply [[expand]] to all terms in the sum.
 <<Particle specifiers: prt spec sum: TBP>>=
   procedure :: expand_sub => prt_spec_sum_expand_sub
 <<Particle specifiers: procedures>>=
   recursive subroutine prt_spec_sum_expand_sub (object)
     class(prt_spec_sum_t), intent(inout) :: object
     integer :: i
     if (allocated (object%expr)) then
        do i = 1, size (object%expr)
           call object%expr(i)%expand ()
        end do
     end if
   end subroutine prt_spec_sum_expand_sub
 
 @ %def prt_spec_sum_expand_sub
 @
 \subsection{Expression Expansion}
 The [[expand]] method transforms each particle specifier expression into a sum
 of lists, according to the rules
 \begin{align}
   a, (b, c) &\to a, b, c
 \\
   a + (b + c) &\to a + b + c
 \\
   a, b + c &\to (a, b) + (a, c)
 \end{align}
 Note that the precedence of comma and plus are opposite to this expansion, so
 the parentheses in the final expression are necessary.
 
 We assume that subexpressions are filled, i.e., arrays are allocated.
 <<Particle specifiers: prt expr: TBP>>=
   procedure :: expand => prt_expr_expand
 <<Particle specifiers: procedures>>=
   recursive subroutine prt_expr_expand (expr)
     class(prt_expr_t), intent(inout) :: expr
     if (allocated (expr%x)) then
        call distribute_prt_spec_list (expr%x)
        call expr%x%expand_sub ()
        select type (x => expr%x)
        type is (prt_spec_list_t)
           call x%flatten ()
        type is (prt_spec_sum_t)
           call x%flatten ()
        end select
     end if
   end subroutine prt_expr_expand
 
 @ %def prt_expr_expand
 @
 \subsection{Unit Tests}
 Test module, followed by the corresponding implementation module.
 <<[[particle_specifiers_ut.f90]]>>=
 <<File header>>
 
 module particle_specifiers_ut
   use unit_tests
   use particle_specifiers_uti
 
 <<Standard module head>>
 
 <<Particle specifiers: public test>>
 
 contains
 
 <<Particle specifiers: test driver>>
 
 end module particle_specifiers_ut
 @ %def particle_specifiers_ut
 @
 <<[[particle_specifiers_uti.f90]]>>=
 <<File header>>
 
 module particle_specifiers_uti
 
 <<Use strings>>
 
   use particle_specifiers
 
 <<Standard module head>>
 
 <<Particle specifiers: test declarations>>
 
 contains
 
 <<Particle specifiers: tests>>
 
 end module particle_specifiers_uti
 @ %def particle_specifiers_ut
 @ API: driver for the unit tests below.
 <<Particle specifiers: public test>>=
   public :: particle_specifiers_test
 <<Particle specifiers: test driver>>=
   subroutine particle_specifiers_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Particle specifiers: execute tests>>
   end subroutine particle_specifiers_test
 
 @ %def particle_specifiers_test
 @
 \subsubsection{Particle specifier array}
 Define, read and write an array of particle specifiers.
 <<Particle specifiers: execute tests>>=
   call test (particle_specifiers_1, "particle_specifiers_1", &
        "Handle particle specifiers", &
        u, results)
 <<Particle specifiers: test declarations>>=
   public :: particle_specifiers_1
 <<Particle specifiers: tests>>=
   subroutine particle_specifiers_1 (u)
     integer, intent(in) :: u
     type(prt_spec_t), dimension(:), allocatable :: prt_spec
     type(string_t), dimension(:), allocatable :: decay
     type(string_t), dimension(0) :: no_decay
     integer :: i, j
 
     write (u, "(A)")  "* Test output: particle_specifiers_1"
     write (u, "(A)")  "*   Purpose: Read and write a particle specifier array"
     write (u, "(A)")
 
     allocate (prt_spec (5))
     prt_spec = [ &
          new_prt_spec (var_str ("a")), &
          new_prt_spec (var_str ("b"), .true.), &
          new_prt_spec (var_str ("c"), [var_str ("dec1")]), &
          new_prt_spec (var_str ("d"), [var_str ("dec1"), var_str ("dec2")]), &
          new_prt_spec (var_str ("e"), no_decay) &
          ]
     do i = 1, size (prt_spec)
        write (u, "(A)")  char (prt_spec(i)%to_string ())
     end do
     write (u, "(A)")
 
     call prt_spec_read (prt_spec, &
          var_str (" a, b( *), c( dec1), d (dec1 + dec2 ), e()"))
     call prt_spec_write (prt_spec, u)
 
     do i = 1, size (prt_spec)
        write (u, "(A)")
        write (u, "(A,A)")  char (prt_spec(i)%get_name ()), ":"
        write (u, "(A,L1)")  "polarized = ", prt_spec(i)%is_polarized ()
        write (u, "(A,L1)")  "unstable  = ", prt_spec(i)%is_unstable ()
        write (u, "(A,I0)")  "n_decays  = ", prt_spec(i)%get_n_decays ()
        call prt_spec(i)%get_decays (decay)
        write (u, "(A)", advance="no") "decays    ="
        do j = 1, size (decay)
           write (u, "(1x,A)", advance="no") char (decay(j))
        end do
        write (u, "(A)")
     end do
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: particle_specifiers_1"
   end subroutine particle_specifiers_1
 
 @ %def particle_specifiers_1
 @
 \subsubsection{Particle specifier expressions}
 Nested expressions (only basic particles, no decay specs).
 <<Particle specifiers: execute tests>>=
   call test (particle_specifiers_2, "particle_specifiers_2", &
        "Particle specifier expressions", &
        u, results)
 <<Particle specifiers: test declarations>>=
   public :: particle_specifiers_2
 <<Particle specifiers: tests>>=
   subroutine particle_specifiers_2 (u)
     integer, intent(in) :: u
     type(prt_spec_t) :: a, b, c, d, e, f
     type(prt_expr_t) :: pe1, pe2, pe3
     type(prt_expr_t) :: pe4, pe5, pe6, pe7, pe8, pe9
     integer :: i
     type(prt_spec_t), dimension(:), allocatable :: pa
 
     write (u, "(A)")  "* Test output: particle_specifiers_2"
     write (u, "(A)")  "*   Purpose: Create and display particle expressions"
     write (u, "(A)")
 
     write (u, "(A)")  "* Basic expressions"
     write (u, *)
 
     a = new_prt_spec (var_str ("a"))
     b = new_prt_spec (var_str ("b"))
     c = new_prt_spec (var_str ("c"))
     d = new_prt_spec (var_str ("d"))
     e = new_prt_spec (var_str ("e"))
     f = new_prt_spec (var_str ("f"))
 
     call pe1%init_spec (a)
     write (u, "(A)")  char (pe1%to_string ())
 
     call pe2%init_sum (2)
     select type (x => pe2%x)
     type is (prt_spec_sum_t)
        call x%expr(1)%init_spec (a)
        call x%expr(2)%init_spec (b)
     end select
     write (u, "(A)")  char (pe2%to_string ())
 
     call pe3%init_list (2)
     select type (x => pe3%x)
     type is (prt_spec_list_t)
        call x%expr(1)%init_spec (a)
        call x%expr(2)%init_spec (b)
     end select
     write (u, "(A)")  char (pe3%to_string ())
 
     write (u, *)
     write (u, "(A)")  "* Nested expressions"
     write (u, *)
 
     call pe4%init_list (2)
     select type (x => pe4%x)
     type is (prt_spec_list_t)
        call x%expr(1)%init_sum (2)
        select type (y => x%expr(1)%x)
        type is (prt_spec_sum_t)
           call y%expr(1)%init_spec (a)
           call y%expr(2)%init_spec (b)
        end select
        call x%expr(2)%init_spec (c)
     end select
     write (u, "(A)")  char (pe4%to_string ())
 
     call pe5%init_list (2)
     select type (x => pe5%x)
     type is (prt_spec_list_t)
        call x%expr(1)%init_list (2)
        select type (y => x%expr(1)%x)
        type is (prt_spec_list_t)
           call y%expr(1)%init_spec (a)
           call y%expr(2)%init_spec (b)
        end select
        call x%expr(2)%init_spec (c)
     end select
     write (u, "(A)")  char (pe5%to_string ())
 
     call pe6%init_sum (2)
     select type (x => pe6%x)
     type is (prt_spec_sum_t)
        call x%expr(1)%init_spec (a)
        call x%expr(2)%init_sum (2)
        select type (y => x%expr(2)%x)
        type is (prt_spec_sum_t)
           call y%expr(1)%init_spec (b)
           call y%expr(2)%init_spec (c)
        end select
     end select
     write (u, "(A)")  char (pe6%to_string ())
 
     call pe7%init_list (2)
     select type (x => pe7%x)
     type is (prt_spec_list_t)
        call x%expr(1)%init_sum (2)
        select type (y => x%expr(1)%x)
        type is (prt_spec_sum_t)
           call y%expr(1)%init_spec (a)
           call y%expr(2)%init_list (2)
           select type (z => y%expr(2)%x)
           type is (prt_spec_list_t)
              call z%expr(1)%init_spec (b)
              call z%expr(2)%init_spec (c)
           end select
        end select
        call x%expr(2)%init_spec (d)
     end select
     write (u, "(A)")  char (pe7%to_string ())
 
     call pe8%init_sum (2)
     select type (x => pe8%x)
     type is (prt_spec_sum_t)
        call x%expr(1)%init_list (2)
        select type (y => x%expr(1)%x)
        type is (prt_spec_list_t)
           call y%expr(1)%init_spec (a)
           call y%expr(2)%init_spec (b)
        end select
        call x%expr(2)%init_list (2)
        select type (y => x%expr(2)%x)
        type is (prt_spec_list_t)
           call y%expr(1)%init_spec (c)
           call y%expr(2)%init_spec (d)
        end select
     end select
     write (u, "(A)")  char (pe8%to_string ())
 
     call pe9%init_list (3)
     select type (x => pe9%x)
     type is (prt_spec_list_t)
        call x%expr(1)%init_sum (2)
        select type (y => x%expr(1)%x)
        type is (prt_spec_sum_t)
           call y%expr(1)%init_spec (a)
           call y%expr(2)%init_spec (b)
        end select
        call x%expr(2)%init_spec (c)
        call x%expr(3)%init_sum (3)
        select type (y => x%expr(3)%x)
        type is (prt_spec_sum_t)
           call y%expr(1)%init_spec (d)
           call y%expr(2)%init_spec (e)
           call y%expr(3)%init_spec (f)
        end select
     end select
     write (u, "(A)")  char (pe9%to_string ())
 
     write (u, *)
     write (u, "(A)")  "* Expand as sum"
     write (u, *)
 
     call pe1%expand ()
     write (u, "(A)")  char (pe1%to_string ())
 
     call pe4%expand ()
     write (u, "(A)")  char (pe4%to_string ())
 
     call pe5%expand ()
     write (u, "(A)")  char (pe5%to_string ())
 
     call pe6%expand ()
     write (u, "(A)")  char (pe6%to_string ())
 
     call pe7%expand ()
     write (u, "(A)")  char (pe7%to_string ())
 
     call pe8%expand ()
     write (u, "(A)")  char (pe8%to_string ())
 
     call pe9%expand ()
     write (u, "(A)")  char (pe9%to_string ())
 
     write (u, *)
     write (u, "(A)")  "* Transform to arrays:"
 
     write (u, "(A)")  "* Atomic specifier"
     do i = 1, pe1%get_n_terms ()
        call pe1%term_to_array (pa, i)
        call prt_spec_write (pa, u)
     end do
 
     write (u, *)
     write (u, "(A)")  "* List"
     do i = 1, pe5%get_n_terms ()
        call pe5%term_to_array (pa, i)
        call prt_spec_write (pa, u)
     end do
 
     write (u, *)
     write (u, "(A)")  "* Sum of atoms"
     do i = 1, pe6%get_n_terms ()
        call pe6%term_to_array (pa, i)
        call prt_spec_write (pa, u)
     end do
 
     write (u, *)
     write (u, "(A)")  "* Sum of lists"
     do i = 1, pe9%get_n_terms ()
        call pe9%term_to_array (pa, i)
        call prt_spec_write (pa, u)
     end do
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: particle_specifiers_2"
   end subroutine particle_specifiers_2
 
 @ %def particle_specifiers_2
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{PDG arrays}
 
 For defining aliases, we introduce a special type which holds a set of
 (integer) PDG codes.
 <<[[pdg_arrays.f90]]>>=
 <<File header>>
 
 module pdg_arrays
 
   use io_units
   use sorting
   use physics_defs, only: UNDEFINED
 
 <<Standard module head>>
 
 <<PDG arrays: public>>
 
 <<PDG arrays: types>>
 
 <<PDG arrays: interfaces>>
 
 contains
 
 <<PDG arrays: procedures>>
 
 end module pdg_arrays
 @ %def pdg_arrays
 @
 \subsection{Type definition}
 Using an allocatable array eliminates the need for initializer and/or
 finalizer.
 <<PDG arrays: public>>=
   public :: pdg_array_t
 <<PDG arrays: types>>=
   type :: pdg_array_t
      private
      integer, dimension(:), allocatable :: pdg
    contains
    <<PDG arrays: pdg array: TBP>>
   end type pdg_array_t
 
 @ %def pdg_array_t
 @ Output
 <<PDG arrays: public>>=
   public :: pdg_array_write
 <<PDG arrays: pdg array: TBP>>=
   procedure :: write => pdg_array_write
 <<PDG arrays: procedures>>=
   subroutine pdg_array_write (aval, unit)
     class(pdg_array_t), intent(in) :: aval
     integer, intent(in), optional :: unit
     integer :: u, i
     u = given_output_unit (unit);  if (u < 0)  return
     write (u, "(A)", advance="no")  "PDG("
     if (allocated (aval%pdg)) then
        do i = 1, size (aval%pdg)
           if (i > 1)  write (u, "(A)", advance="no")  ", "
           write (u, "(I0)", advance="no")  aval%pdg(i)
        end do
     end if
     write (u, "(A)", advance="no")  ")"
   end subroutine pdg_array_write
 
 @ %def pdg_array_write
 @
 <<PDG arrays: public>>=
   public :: pdg_array_write_set
 <<PDG arrays: procedures>>=
   subroutine pdg_array_write_set (aval, unit)
     type(pdg_array_t), intent(in), dimension(:) :: aval
     integer, intent(in), optional :: unit
     integer :: i
     do i = 1, size (aval)
        call aval(i)%write (unit)
        print *, ''
     end do
   end subroutine pdg_array_write_set
 
 @ %def pdg_array_write_set
 @
 \subsection{Basic operations}
 Assignment.  We define assignment from and to an integer array.
 Note that the integer array, if it is the l.h.s., must be declared
 allocatable by the caller.
 <<PDG arrays: public>>=
   public :: assignment(=)
 <<PDG arrays: interfaces>>=
   interface assignment(=)
      module procedure pdg_array_from_int_array
      module procedure pdg_array_from_int
      module procedure int_array_from_pdg_array
   end interface
 
 <<PDG arrays: procedures>>=
   subroutine pdg_array_from_int_array (aval, iarray)
     type(pdg_array_t), intent(out) :: aval
     integer, dimension(:), intent(in) :: iarray
     allocate (aval%pdg (size (iarray)))
     aval%pdg = iarray
   end subroutine pdg_array_from_int_array
 
   elemental subroutine pdg_array_from_int (aval, int)
     type(pdg_array_t), intent(out) :: aval
     integer, intent(in) :: int
     allocate (aval%pdg (1))
     aval%pdg = int
   end subroutine pdg_array_from_int
 
   subroutine int_array_from_pdg_array (iarray, aval)
     integer, dimension(:), allocatable, intent(out) :: iarray
     type(pdg_array_t), intent(in) :: aval
     if (allocated (aval%pdg)) then
        allocate (iarray (size (aval%pdg)))
        iarray = aval%pdg
     else
        allocate (iarray (0))
     end if
   end subroutine int_array_from_pdg_array
   
 @ %def pdg_array_from_int_array pdg_array_from_int int_array_from_pdg_array 
 @ Allocate space for a PDG array
 <<PDG arrays: public>>=
   public :: pdg_array_init
 <<PDG arrays: procedures>>=
   subroutine pdg_array_init (aval, n_elements)
     type(pdg_array_t), intent(inout) :: aval
     integer, intent(in) :: n_elements
     allocate(aval%pdg(n_elements))
   end subroutine pdg_array_init
 
 @ %def pdg_array_init
 @ Deallocate a previously allocated pdg array
 <<PDG arrays: public>>=
   public :: pdg_array_delete
 <<PDG arrays: procedures>>=
   subroutine pdg_array_delete (aval)
     type(pdg_array_t), intent(inout) :: aval
     if (allocated (aval%pdg)) deallocate (aval%pdg)
   end subroutine pdg_array_delete
 
 @ %def pdg_array_delete
 @ Merge two pdg arrays, i.e. append a particle string to another leaving out doublettes
 <<PDG arrays: public>>=
   public :: pdg_array_merge
 <<PDG arrays: procedures>>=
   subroutine pdg_array_merge (aval1, aval2)
     type(pdg_array_t), intent(inout) :: aval1
     type(pdg_array_t), intent(in) :: aval2
     type(pdg_array_t) :: aval
     if (allocated (aval1%pdg) .and. allocated (aval2%pdg)) then
       if (.not. any (aval1%pdg == aval2%pdg)) aval = aval1 // aval2
     else if (allocated (aval1%pdg)) then
       aval = aval1
     else if (allocated (aval2%pdg)) then
       aval = aval2
     end if
     call pdg_array_delete (aval1)
     aval1 = aval%pdg
   end subroutine pdg_array_merge
 
 @ %def pdg_array_merge
 @ Length of the array.
 <<PDG arrays: public>>=
   public :: pdg_array_get_length
 <<PDG arrays: pdg array: TBP>>=
   procedure :: get_length => pdg_array_get_length
 <<PDG arrays: procedures>>=
   elemental function pdg_array_get_length (aval) result (n)
     class(pdg_array_t), intent(in) :: aval
     integer :: n
     if (allocated (aval%pdg)) then
        n = size (aval%pdg)
     else
        n = 0
     end if
   end function pdg_array_get_length
 
 @ %def pdg_array_get_length
 @ Return the element with index i.
 <<PDG arrays: public>>=
   public :: pdg_array_get
 <<PDG arrays: pdg array: TBP>>=
   procedure :: get => pdg_array_get
 <<PDG arrays: procedures>>=
   elemental function pdg_array_get (aval, i) result (pdg)
     class(pdg_array_t), intent(in) :: aval
     integer, intent(in), optional :: i
     integer :: pdg
     if (present (i)) then
        pdg = aval%pdg(i)
     else
        pdg = aval%pdg(1)
     end if
   end function pdg_array_get
 
 @ %def pdg_array_get
 @ Explicitly set the element with index i.
 <<PDG arrays: pdg array: TBP>>=
   procedure :: set => pdg_array_set
 <<PDG arrays: procedures>>=
   subroutine pdg_array_set (aval, i, pdg)
     class(pdg_array_t), intent(inout) :: aval
     integer, intent(in) :: i
     integer, intent(in) :: pdg
     aval%pdg(i) = pdg
   end subroutine pdg_array_set
 
 @ %def pdg_array_set
 @
 <<PDG arrays: pdg array: TBP>>=
   procedure :: add => pdg_array_add
 <<PDG arrays: procedures>>=
   function pdg_array_add (aval, aval_add) result (aval_out)
     type(pdg_array_t) :: aval_out
     class(pdg_array_t), intent(in) :: aval
     type(pdg_array_t), intent(in) :: aval_add
     integer :: n, n_add, i
     n = size (aval%pdg)
     n_add = size (aval_add%pdg)
     allocate (aval_out%pdg (n + n_add))
     aval_out%pdg(1:n) = aval%pdg
     do i = 1, n_add
        aval_out%pdg(n+i) = aval_add%pdg(i)
     end do
   end function pdg_array_add
 
 @ %def pdg_array_add
 @ Replace element with index [[i]] by a new array of elements.
 <<PDG arrays: public>>=
   public :: pdg_array_replace
 <<PDG arrays: pdg array: TBP>>=
   procedure :: replace => pdg_array_replace
 <<PDG arrays: procedures>>=
   function pdg_array_replace (aval, i, pdg_new) result (aval_new)
     class(pdg_array_t), intent(in) :: aval
     integer, intent(in) :: i
     integer, dimension(:), intent(in) :: pdg_new
     type(pdg_array_t) :: aval_new
     integer :: n, l
     n = size (aval%pdg)
     l = size (pdg_new)
     allocate (aval_new%pdg (n + l - 1))
     aval_new%pdg(:i-1) = aval%pdg(:i-1)
     aval_new%pdg(i:i+l-1) = pdg_new
     aval_new%pdg(i+l:) = aval%pdg(i+1:)
   end function pdg_array_replace
 
 @ %def pdg_array_replace
 @ Concatenate two PDG arrays
 <<PDG arrays: public>>=
   public :: operator(//)
 <<PDG arrays: interfaces>>=
   interface operator(//)
      module procedure concat_pdg_arrays
   end interface
 
 <<PDG arrays: procedures>>=
   function concat_pdg_arrays (aval1, aval2) result (aval)
     type(pdg_array_t) :: aval
     type(pdg_array_t), intent(in) :: aval1, aval2
     integer :: n1, n2
     if (allocated (aval1%pdg) .and. allocated (aval2%pdg)) then
        n1 = size (aval1%pdg)
        n2 = size (aval2%pdg)
        allocate (aval%pdg (n1 + n2))
        aval%pdg(:n1) = aval1%pdg
        aval%pdg(n1+1:) = aval2%pdg
     else if (allocated (aval1%pdg)) then
        aval = aval1
     else if (allocated (aval2%pdg)) then
        aval = aval2
     end if
   end function concat_pdg_arrays
 
 @ %def concat_pdg_arrays
 @
 \subsection{Matching}
 A PDG array matches a given PDG code if the code is present within the
 array.  If either one is zero (UNDEFINED), the match also succeeds.
 <<PDG arrays: public>>=
   public :: operator(.match.)
 <<PDG arrays: interfaces>>=
   interface operator(.match.)
      module procedure pdg_array_match_integer
      module procedure pdg_array_match_pdg_array
   end interface
 
 @ %def .match.
 @ Match a single code against the array.
 <<PDG arrays: procedures>>=
   elemental function pdg_array_match_integer (aval, pdg) result (flag)
     logical :: flag
     type(pdg_array_t), intent(in) :: aval
     integer, intent(in) :: pdg
     if (allocated (aval%pdg)) then
        flag = pdg == UNDEFINED &
             .or. any (aval%pdg == UNDEFINED) &
             .or. any (aval%pdg == pdg)
     else
        flag = .false.
     end if
   end function pdg_array_match_integer
 
 @ %def pdg_array_match_integer
 @ Check if the pdg-number corresponds to a quark
 <<PDG arrays: public>>=
   public :: is_quark
 <<PDG arrays: procedures>>=
   elemental function is_quark (pdg_nr)
     logical :: is_quark
     integer, intent(in) :: pdg_nr
     if (abs (pdg_nr) >= 1 .and. abs (pdg_nr) <= 6) then
        is_quark = .true.
     else
        is_quark = .false.
     end if
   end function is_quark
 
 @ %def is_quark
 @ Check if pdg-number corresponds to a gluon
 <<PDG arrays: public>>=
   public :: is_gluon
 <<PDG arrays: procedures>>=
   elemental function is_gluon (pdg_nr)
     logical :: is_gluon
     integer, intent(in) :: pdg_nr
     if (pdg_nr == 21) then
        is_gluon = .true.
     else
        is_gluon = .false.
     end if
   end function is_gluon
 
 @ %def is_gluon
 @ Check if pdg-number corresponds to a photon
 <<PDG arrays: public>>=
   public :: is_photon
 <<PDG arrays: procedures>>=
   elemental function is_photon (pdg_nr)
     logical :: is_photon
     integer, intent(in) :: pdg_nr
     if (pdg_nr == 22) then
        is_photon = .true.
     else
        is_photon = .false.
     end if
   end function is_photon
 
 @ %def is_photon
 @ Check if pdg-number corresponds to a colored particle
 <<PDG arrays: public>>=
   public :: is_colored
 <<PDG arrays: procedures>>=
   elemental function is_colored (pdg_nr)
     logical :: is_colored
     integer, intent(in) :: pdg_nr
     is_colored = is_quark (pdg_nr) .or. is_gluon (pdg_nr)
   end function is_colored
 
 @ %def is_colored
 @ Check if the pdg-number corresponds to a lepton
 <<PDG arrays: public>>=
   public :: is_lepton
 <<PDG arrays: procedures>>=
   elemental function is_lepton (pdg_nr)
     logical :: is_lepton
     integer, intent(in) :: pdg_nr
     if (abs (pdg_nr) >= 11 .and. abs (pdg_nr) <= 16) then
       is_lepton = .true.
     else
       is_lepton = .false.
     end if
   end function is_lepton
 
 @ %def is_lepton
 @
 <<PDG arrays: public>>=
   public :: is_fermion
 <<PDG arrays: procedures>>=
   elemental function is_fermion (pdg_nr)
     logical :: is_fermion
     integer, intent(in) :: pdg_nr
     is_fermion = is_lepton(pdg_nr) .or. is_quark(pdg_nr)
   end function is_fermion
 
 @ %def is_fermion
 @ Check if the pdg-number corresponds to a massless vector boson
 <<PDG arrays: public>>=
   public :: is_massless_vector
 <<PDG arrays: procedures>>=
   elemental function is_massless_vector (pdg_nr)
     integer, intent(in) :: pdg_nr
     logical :: is_massless_vector
     if (pdg_nr == 21 .or. pdg_nr == 22) then
       is_massless_vector = .true.
     else
       is_massless_vector = .false.
     end if
   end function is_massless_vector
 
 @ %def is_massless_vector
 @ Check if pdg-number corresponds to a massive vector boson
 <<PDG arrays: public>>=
   public :: is_massive_vector
 <<PDG arrays: procedures>>=
   elemental function is_massive_vector (pdg_nr)
     integer, intent(in) :: pdg_nr
     logical :: is_massive_vector
     if (abs (pdg_nr) == 23 .or. abs (pdg_nr) == 24) then
       is_massive_vector = .true.
     else
       is_massive_vector = .false.
     end if
   end function is_massive_vector
 
 @ %def is massive_vector
 @ Check if pdg-number corresponds to a vector boson
 <<PDG arrays: public>>=
   public :: is_vector
 <<PDG arrays: procedures>>=
   elemental function is_vector (pdg_nr)
     integer, intent(in) :: pdg_nr
     logical :: is_vector
     if (is_massless_vector (pdg_nr) .or. is_massive_vector (pdg_nr)) then
       is_vector = .true.
     else
       is_vector = .false.
     end if
   end function is_vector
 
 @ %def is vector
 @ Check if particle is elementary.
 <<PDG arrays: public>>=
   public :: is_elementary
 <<PDG arrays: procedures>>=
   elemental function is_elementary (pdg_nr)
     integer, intent(in) :: pdg_nr
     logical :: is_elementary
     if (is_vector (pdg_nr) .or. is_fermion (pdg_nr) .or. pdg_nr == 25) then
        is_elementary = .true.
     else
        is_elementary = .false.
     end if
   end function is_elementary
 
 @ %def is_elementary
 @ Check if particle is strongly interacting
 <<PDG arrays: pdg array: TBP>>=
   procedure :: has_colored_particles => pdg_array_has_colored_particles
 <<PDG arrays: procedures>>=
   function pdg_array_has_colored_particles (pdg) result (colored)
     class(pdg_array_t), intent(in) :: pdg
     logical :: colored
     integer :: i, pdg_nr
     colored = .false.
     do i = 1, size (pdg%pdg)
       pdg_nr = pdg%pdg(i)
       if (is_quark (pdg_nr) .or. is_gluon (pdg_nr)) then
          colored = .true.
          exit
       end if
     end do
   end function pdg_array_has_colored_particles
 
 @ %def pdg_array_has_colored_particles
 @ Match two arrays.  Succeeds if any pair of entries matches.
 <<PDG arrays: procedures>>=
   function pdg_array_match_pdg_array (aval1, aval2) result (flag)
     logical :: flag
     type(pdg_array_t), intent(in) :: aval1, aval2
     if (allocated (aval1%pdg) .and. allocated (aval2%pdg)) then
        flag = any (aval1 .match. aval2%pdg)
     else
        flag = .false.
     end if
   end function pdg_array_match_pdg_array
 
 @ %def pdg_array_match_pdg_array
 @ Comparison.  Here, we take the PDG arrays as-is, assuming that they
 are sorted.
 
 The ordering is a bit odd: first, we look only at the absolute values
 of the PDG codes.  If they all match, the particle comes before the
 antiparticle, scanning from left to right.
 <<PDG arrays: public>>=
   public :: operator(<)
   public :: operator(>)
   public :: operator(<=)
   public :: operator(>=)
   public :: operator(==)
   public :: operator(/=)
 <<PDG arrays: interfaces>>=
   interface operator(<)
      module procedure pdg_array_lt
   end interface
   interface operator(>)
      module procedure pdg_array_gt
   end interface
   interface operator(<=)
      module procedure pdg_array_le
   end interface
   interface operator(>=)
      module procedure pdg_array_ge
   end interface
   interface operator(==)
      module procedure pdg_array_eq
   end interface
   interface operator(/=)
      module procedure pdg_array_ne
   end interface
 
 <<PDG arrays: procedures>>=
   elemental function pdg_array_lt (aval1, aval2) result (flag)
     type(pdg_array_t), intent(in) :: aval1, aval2
     logical :: flag
     integer :: i
     if (size (aval1%pdg) /= size (aval2%pdg)) then
        flag = size (aval1%pdg) < size (aval2%pdg)
     else
        do i = 1, size (aval1%pdg)
           if (abs (aval1%pdg(i)) /= abs (aval2%pdg(i))) then
              flag = abs (aval1%pdg(i)) < abs (aval2%pdg(i))
              return
           end if
        end do
        do i = 1, size (aval1%pdg)
           if (aval1%pdg(i) /= aval2%pdg(i)) then
              flag = aval1%pdg(i) > aval2%pdg(i)
              return
           end if
        end do
        flag = .false.
     end if
   end function pdg_array_lt
 
   elemental function pdg_array_gt (aval1, aval2) result (flag)
     type(pdg_array_t), intent(in) :: aval1, aval2
     logical :: flag
     flag = .not. (aval1 < aval2 .or. aval1 == aval2)
   end function pdg_array_gt
 
   elemental function pdg_array_le (aval1, aval2) result (flag)
     type(pdg_array_t), intent(in) :: aval1, aval2
     logical :: flag
     flag = aval1 < aval2 .or. aval1 == aval2
   end function pdg_array_le
 
   elemental function pdg_array_ge (aval1, aval2) result (flag)
     type(pdg_array_t), intent(in) :: aval1, aval2
     logical :: flag
     flag = .not. (aval1 < aval2)
   end function pdg_array_ge
 
   elemental function pdg_array_eq (aval1, aval2) result (flag)
     type(pdg_array_t), intent(in) :: aval1, aval2
     logical :: flag
     if (size (aval1%pdg) /= size (aval2%pdg)) then
        flag = .false.
     else
        flag = all (aval1%pdg == aval2%pdg)
     end if
   end function pdg_array_eq
 
   elemental function pdg_array_ne (aval1, aval2) result (flag)
     type(pdg_array_t), intent(in) :: aval1, aval2
     logical :: flag
     flag = .not. (aval1 == aval2)
   end function pdg_array_ne
 
 @ Equivalence.  Two PDG arrays are equivalent if either one contains
 [[UNDEFINED]] or if each element of array 1 is present in array 2, and
 vice versa.
 <<PDG arrays: public>>=
   public :: operator(.eqv.)
   public :: operator(.neqv.)
 <<PDG arrays: interfaces>>=
   interface operator(.eqv.)
      module procedure pdg_array_equivalent
   end interface
   interface operator(.neqv.)
      module procedure pdg_array_inequivalent
   end interface
 
 <<PDG arrays: procedures>>=
   elemental function pdg_array_equivalent (aval1, aval2) result (eq)
     logical :: eq
     type(pdg_array_t), intent(in) :: aval1, aval2
     logical, dimension(:), allocatable :: match1, match2
     integer :: i
     if (allocated (aval1%pdg) .and. allocated (aval2%pdg)) then
        eq = any (aval1%pdg == UNDEFINED) &
             .or. any (aval2%pdg == UNDEFINED)
        if (.not. eq) then
           allocate (match1 (size (aval1%pdg)))
           allocate (match2 (size (aval2%pdg)))
           match1 = .false.
           match2 = .false.
           do i = 1, size (aval1%pdg)
              match2 = match2 .or. aval1%pdg(i) == aval2%pdg
           end do
           do i = 1, size (aval2%pdg)
              match1 = match1 .or. aval2%pdg(i) == aval1%pdg
           end do
           eq = all (match1) .and. all (match2)
        end if
     else
        eq = .false.
     end if
   end function pdg_array_equivalent
 
   elemental function pdg_array_inequivalent (aval1, aval2) result (neq)
     logical :: neq
     type(pdg_array_t), intent(in) :: aval1, aval2
     neq = .not. pdg_array_equivalent (aval1, aval2)
   end function pdg_array_inequivalent
 
 @ %def pdg_array_equivalent
 @
 \subsection{Sorting}
 Sort a PDG array by absolute value, particle before antiparticle.  After
 sorting, we eliminate double entries.
 <<PDG arrays: public>>=
   public :: sort_abs
 <<PDG arrays: interfaces>>=
   interface sort_abs
      module procedure pdg_array_sort_abs
   end interface
 
 <<PDG arrays: pdg array: TBP>>=
   procedure :: sort_abs => pdg_array_sort_abs
 <<PDG arrays: procedures>>=
   function pdg_array_sort_abs (aval1, unique) result (aval2)
     class(pdg_array_t), intent(in) :: aval1
     logical, intent(in), optional :: unique
     type(pdg_array_t) :: aval2
     integer, dimension(:), allocatable :: tmp
     logical, dimension(:), allocatable :: mask
     integer :: i, n
     logical :: uni
     uni = .false.;  if (present (unique))  uni = unique
     n = size (aval1%pdg)
     if (uni) then
        allocate (tmp (n), mask(n))
        tmp = sort_abs (aval1%pdg)
        mask(1) = .true.
        do i = 2, n
           mask(i) = tmp(i) /= tmp(i-1)
        end do
        allocate (aval2%pdg (count (mask)))
        aval2%pdg = pack (tmp, mask)
     else
        allocate (aval2%pdg (n))
        aval2%pdg = sort_abs (aval1%pdg)
     end if
   end function pdg_array_sort_abs
 
 @ %def sort_abs
 @
 <<PDG arrays: pdg array: TBP>>=
   procedure :: intersect => pdg_array_intersect
 <<PDG arrays: procedures>>=
   function pdg_array_intersect (aval1, match) result (aval2)
    class(pdg_array_t), intent(in) :: aval1
    integer, dimension(:) :: match
    type(pdg_array_t) :: aval2
    integer, dimension(:), allocatable :: isec
    integer :: i
    isec = pack (aval1%pdg, [(any(aval1%pdg(i) == match), i=1,size(aval1%pdg))])
    aval2 = isec
   end function pdg_array_intersect
 
 @ %def pdg_array_intersect
 @
 <<PDG arrays: pdg array: TBP>>=
   procedure :: search_for_particle => pdg_array_search_for_particle
 <<PDG arrays: procedures>>=
   elemental function pdg_array_search_for_particle (pdg, i_part) result (found)
     class(pdg_array_t), intent(in) :: pdg
     integer, intent(in) :: i_part
     logical :: found
     found = any (pdg%pdg == i_part)
   end function pdg_array_search_for_particle
 
 @ %def pdg_array_search_for_particle
 @
 <<PDG arrays: pdg array: TBP>>=
   procedure :: invert => pdg_array_invert
 <<PDG arrays: procedures>>=
   function pdg_array_invert (pdg) result (pdg_inverse)
     class(pdg_array_t), intent(in) :: pdg
     type(pdg_array_t) :: pdg_inverse
     integer :: i, n
     n = size (pdg%pdg)
     allocate (pdg_inverse%pdg (n))
     do i = 1, n
        select case (pdg%pdg(i))
        case (21, 22, 23, 25)
           pdg_inverse%pdg(i) = pdg%pdg(i)
        case default
           pdg_inverse%pdg(i) = -pdg%pdg(i)
        end select
     end do
   end function pdg_array_invert
 
 @ %def pdg_array_invert
 @
 \subsection{PDG array list}
 A PDG array list, or PDG list, is an array of PDG-array objects with
 some convenience methods.
 <<PDG arrays: public>>=
   public :: pdg_list_t
 <<PDG arrays: types>>=
   type :: pdg_list_t
      type(pdg_array_t), dimension(:), allocatable :: a
    contains
    <<PDG arrays: pdg list: TBP>>
   end type pdg_list_t
 
 @ %def pdg_list_t
 @ Output, as a comma-separated list without advancing I/O.
 <<PDG arrays: pdg list: TBP>>=
   procedure :: write => pdg_list_write
 <<PDG arrays: procedures>>=
   subroutine pdg_list_write (object, unit)
     class(pdg_list_t), intent(in) :: object
     integer, intent(in), optional :: unit
     integer :: u, i
     u = given_output_unit (unit)
     if (allocated (object%a)) then
        do i = 1, size (object%a)
           if (i > 1)  write (u, "(A)", advance="no")  ", "
           call object%a(i)%write (u)
        end do
     end if
   end subroutine pdg_list_write
 
 @ %def pdg_list_write
 @ Initialize for a certain size.  The entries are initially empty PDG arrays.
 <<PDG arrays: pdg list: TBP>>=
   generic :: init => pdg_list_init_size
   procedure, private :: pdg_list_init_size
 <<PDG arrays: procedures>>=
   subroutine pdg_list_init_size (pl, n)
     class(pdg_list_t), intent(out) :: pl
     integer, intent(in) :: n
     allocate (pl%a (n))
   end subroutine pdg_list_init_size
 
 @ %def pdg_list_init_size
 @ Initialize with a definite array of PDG codes.  That is, each entry
 in the list becomes a single-particle PDG array.
 <<PDG arrays: pdg list: TBP>>=
   generic :: init => pdg_list_init_int_array
   procedure, private :: pdg_list_init_int_array
 <<PDG arrays: procedures>>=
   subroutine pdg_list_init_int_array (pl, pdg)
     class(pdg_list_t), intent(out) :: pl
     integer, dimension(:), intent(in) :: pdg
     integer :: i
     allocate (pl%a (size (pdg)))
     do i = 1, size (pdg)
        pl%a(i) = pdg(i)
     end do
   end subroutine pdg_list_init_int_array
 
 @ %def pdg_list_init_array
 @ Set one of the entries.  No bounds-check.
 <<PDG arrays: pdg list: TBP>>=
   generic :: set => pdg_list_set_int
   generic :: set => pdg_list_set_int_array
   generic :: set => pdg_list_set_pdg_array
   procedure, private :: pdg_list_set_int
   procedure, private :: pdg_list_set_int_array
   procedure, private :: pdg_list_set_pdg_array
 <<PDG arrays: procedures>>=
   subroutine pdg_list_set_int (pl, i, pdg)
     class(pdg_list_t), intent(inout) :: pl
     integer, intent(in) :: i
     integer, intent(in) :: pdg
     pl%a(i) = pdg
   end subroutine pdg_list_set_int
 
   subroutine pdg_list_set_int_array (pl, i, pdg)
     class(pdg_list_t), intent(inout) :: pl
     integer, intent(in) :: i
     integer, dimension(:), intent(in) :: pdg
     pl%a(i) = pdg
   end subroutine pdg_list_set_int_array
 
   subroutine pdg_list_set_pdg_array (pl, i, pa)
     class(pdg_list_t), intent(inout) :: pl
     integer, intent(in) :: i
     type(pdg_array_t), intent(in) :: pa
     pl%a(i) = pa
   end subroutine pdg_list_set_pdg_array
 
 @ %def pdg_list_set
 @ Array size, not the length of individual entries
 <<PDG arrays: pdg list: TBP>>=
   procedure :: get_size => pdg_list_get_size
 <<PDG arrays: procedures>>=
   function pdg_list_get_size (pl) result (n)
     class(pdg_list_t), intent(in) :: pl
     integer :: n
     if (allocated (pl%a)) then
        n = size (pl%a)
     else
        n = 0
     end if
   end function pdg_list_get_size
 
 @ %def pdg_list_get_size
 @ Return an entry, as a PDG array.
 <<PDG arrays: pdg list: TBP>>=
   procedure :: get => pdg_list_get
 <<PDG arrays: procedures>>=
   function pdg_list_get (pl, i) result (pa)
     type(pdg_array_t) :: pa
     class(pdg_list_t), intent(in) :: pl
     integer, intent(in) :: i
     pa = pl%a(i)
   end function pdg_list_get
 
 @ %def pdg_list_get
 @ Check if the list entries are all either mutually disjoint or identical.
 The individual entries (PDG arrays) should already be sorted, so we can test
 for equality.
 <<PDG arrays: pdg list: TBP>>=
   procedure :: is_regular => pdg_list_is_regular
 <<PDG arrays: procedures>>=
   function pdg_list_is_regular (pl) result (flag)
     class(pdg_list_t), intent(in) :: pl
     logical :: flag
     integer :: i, j, s
     s = pl%get_size ()
     flag = .true.
     do i = 1, s
        do j = i + 1, s
           if (pl%a(i) .match. pl%a(j)) then
              if (pl%a(i) /= pl%a(j)) then
                 flag = .false.
                 return
              end if
           end if
        end do
     end do
   end function pdg_list_is_regular
 
 @ %def pdg_list_is_regular
 @ Sort the list.  First, each entry gets sorted, including elimination
 of doublers.  Then, we sort the list, using the first member of each
 PDG array as the marker.  No removal of doublers at this stage.
 
 If [[n_in]] is supplied, we do not reorder the first [[n_in]] particle
 entries.
 <<PDG arrays: pdg list: TBP>>=
   procedure :: sort_abs => pdg_list_sort_abs
 <<PDG arrays: procedures>>=
   function pdg_list_sort_abs (pl, n_in) result (pl_sorted)
     class(pdg_list_t), intent(in) :: pl
     integer, intent(in), optional :: n_in
     type(pdg_list_t) :: pl_sorted
     type(pdg_array_t), dimension(:), allocatable :: pa
     integer, dimension(:), allocatable :: pdg, map
     integer :: i, n0
     call pl_sorted%init (pl%get_size ())
     if (allocated (pl%a)) then
        allocate (pa (size (pl%a)))
        do i = 1, size (pl%a)
           pa(i) = pl%a(i)%sort_abs (unique = .true.)
        end do
        allocate (pdg (size (pa)), source = 0)
        do i = 1, size (pa)
           if (allocated (pa(i)%pdg)) then
              if (size (pa(i)%pdg) > 0) then
                 pdg(i) = pa(i)%pdg(1)
              end if
           end if
        end do
        if (present (n_in)) then
           n0 = n_in
        else
           n0 = 0
        end if
        allocate (map (size (pdg)))
        map(:n0) = [(i, i = 1, n0)]
        map(n0+1:) = n0 + order_abs (pdg(n0+1:))
        do i = 1, size (pa)
           call pl_sorted%set (i, pa(map(i)))
        end do
     end if
   end function pdg_list_sort_abs
 
 @ %def pdg_list_sort_abs
 @ Compare sorted lists: equality.  The result is undefined if some entries
 are not allocated.
 <<PDG arrays: pdg list: TBP>>=
   generic :: operator (==) => pdg_list_eq
   procedure, private :: pdg_list_eq
 <<PDG arrays: procedures>>=
   function pdg_list_eq (pl1, pl2) result (flag)
     class(pdg_list_t), intent(in) :: pl1, pl2
     logical :: flag
     integer :: i
     flag = .false.
     if (allocated (pl1%a) .and. allocated (pl2%a)) then
        if (size (pl1%a) == size (pl2%a)) then
           do i = 1, size (pl1%a)
              associate (a1 => pl1%a(i), a2 => pl2%a(i))
                if (allocated (a1%pdg) .and. allocated (a2%pdg)) then
                   if (size (a1%pdg) == size (a2%pdg)) then
                      if (size (a1%pdg) > 0) then
                         if (a1%pdg(1) /= a2%pdg(1)) return
                      end if
                   else
                      return
                   end if
                else
                   return
                end if
              end associate
           end do
           flag = .true.
        end if
     end if
   end function pdg_list_eq
 
 @ %def pdg_list_eq
 @ Compare sorted lists.  The result is undefined if some entries
 are not allocated.
 
 The ordering is quite complicated.  First, a shorter list comes before
 a longer list.  Comparing entry by entry, a shorter entry comes
 first.  Next, we check the first PDG code within corresponding
 entries.  This is compared by absolute value.  If equal, particle
 comes before antiparticle.  Finally, if all is equal, the result is
 false.
 <<PDG arrays: pdg list: TBP>>=
   generic :: operator (<) => pdg_list_lt
   procedure, private :: pdg_list_lt
 <<PDG arrays: procedures>>=
   function pdg_list_lt (pl1, pl2) result (flag)
     class(pdg_list_t), intent(in) :: pl1, pl2
     logical :: flag
     integer :: i
     flag = .false.
     if (allocated (pl1%a) .and. allocated (pl2%a)) then
        if (size (pl1%a) < size (pl2%a)) then
           flag = .true.;  return
        else if (size (pl1%a) > size (pl2%a)) then
           return
        else
           do i = 1, size (pl1%a)
              associate (a1 => pl1%a(i), a2 => pl2%a(i))
                if (allocated (a1%pdg) .and. allocated (a2%pdg)) then
                   if (size (a1%pdg) < size (a2%pdg)) then
                      flag = .true.;  return
                   else if (size (a1%pdg) > size (a2%pdg)) then
                      return
                   else
                      if (size (a1%pdg) > 0) then
                         if (abs (a1%pdg(1)) < abs (a2%pdg(1))) then
                            flag = .true.;  return
                         else if (abs (a1%pdg(1)) > abs (a2%pdg(1))) then
                            return
                         else if (a1%pdg(1) > 0 .and. a2%pdg(1) < 0) then
                            flag = .true.;  return
                         else if (a1%pdg(1) < 0 .and. a2%pdg(1) > 0) then
                            return
                         end if
                      end if
                   end if
                else
                   return
                end if
              end associate
           end do
           flag = .false.
        end if
     end if
   end function pdg_list_lt
 
 @ %def pdg_list_lt
 @ Replace an entry.  In the result, the entry [[#i]] is replaced by
 the contents of the second argument.  The result is not sorted.
 
 If [[n_in]] is also set and [[i]] is less or equal to [[n_in]],
 replace [[#i]] only by the first entry of [[pl_insert]], and insert
 the remainder after entry [[n_in]].
 <<PDG arrays: pdg list: TBP>>=
   procedure :: replace => pdg_list_replace
 <<PDG arrays: procedures>>=
   function pdg_list_replace (pl, i, pl_insert, n_in) result (pl_out)
     type(pdg_list_t) :: pl_out
     class(pdg_list_t), intent(in) :: pl
     integer, intent(in) :: i
     class(pdg_list_t), intent(in) :: pl_insert
     integer, intent(in), optional :: n_in
     integer :: n, n_insert, n_out, k
     n = pl%get_size ()
     n_insert = pl_insert%get_size ()
     n_out = n + n_insert - 1
     call pl_out%init (n_out)
 !    if (allocated (pl%a)) then
        do k = 1, i - 1
           pl_out%a(k) = pl%a(k)
        end do
 !    end if
     if (present (n_in)) then
        pl_out%a(i) = pl_insert%a(1)
        do k = i + 1, n_in
           pl_out%a(k) = pl%a(k)
        end do
        do k = 1, n_insert - 1
           pl_out%a(n_in+k) = pl_insert%a(1+k)
        end do
        do k = 1, n - n_in
           pl_out%a(n_in+k+n_insert-1) = pl%a(n_in+k)
        end do
     else
 !       if (allocated (pl_insert%a)) then
           do k = 1, n_insert
              pl_out%a(i-1+k) = pl_insert%a(k)
           end do
 !       end if
 !       if (allocated (pl%a)) then
           do k = 1, n - i
              pl_out%a(i+n_insert-1+k) = pl%a(i+k)
           end do
        end if
 !    end if
   end function pdg_list_replace
 
 @ %def pdg_list_replace
 @
 <<PDG arrays: pdg list: TBP>>=
   procedure :: fusion => pdg_list_fusion
 <<PDG arrays: procedures>>=
   function pdg_list_fusion (pl, pl_insert, i, check_if_existing) result (pl_out)
     type(pdg_list_t) :: pl_out
     class(pdg_list_t), intent(in) :: pl
     type(pdg_list_t), intent(in) :: pl_insert
     integer, intent(in) :: i
     logical, intent(in) :: check_if_existing
     integer :: n, n_insert, k, n_out
     logical :: new_pdg
     n = pl%get_size ()
     n_insert = pl_insert%get_size ()
     new_pdg = .not. check_if_existing .or. &
          (.not. any (pl%search_for_particle (pl_insert%a(1)%pdg)))
     call pl_out%init (n + n_insert - 1)
     do k = 1, n
        if (new_pdg .and. k == i) then
           pl_out%a(k) = pl%a(k)%add (pl_insert%a(1))
        else
           pl_out%a(k) = pl%a(k)
        end if
     end do
     do k = n + 1, n + n_insert - 1
        pl_out%a(k) = pl_insert%a(k-n)
     end do
   end function pdg_list_fusion
 
 @ %def pdg_list_fusion
 @
 <<PDG arrays: pdg list: TBP>>=
   procedure :: get_pdg_sizes => pdg_list_get_pdg_sizes
 <<PDG arrays: procedures>>=
   function pdg_list_get_pdg_sizes (pl) result (i_size)
     integer, dimension(:), allocatable :: i_size
     class(pdg_list_t), intent(in) :: pl
     integer :: i, n
     n = pl%get_size ()
     allocate (i_size (n))
     do i = 1, n
        i_size(i) = size (pl%a(i)%pdg)
     end do
   end function pdg_list_get_pdg_sizes
 
 @ %def pdg_list_get_pdg_sizes
 @ Replace the entries of [[pl]] by the matching entries of [[pl_match]], one by
 one.  This is done in-place.  If there is no match, return failure.
 <<PDG arrays: pdg list: TBP>>=
   procedure :: match_replace => pdg_list_match_replace
 <<PDG arrays: procedures>>=
   subroutine pdg_list_match_replace (pl, pl_match, success)
     class(pdg_list_t), intent(inout) :: pl
     class(pdg_list_t), intent(in) :: pl_match
     logical, intent(out) :: success
     integer :: i, j
     success = .true.
     SCAN_ENTRIES: do i = 1, size (pl%a)
        do j = 1, size (pl_match%a)
           if (pl%a(i) .match. pl_match%a(j)) then
              pl%a(i) = pl_match%a(j)
              cycle SCAN_ENTRIES
           end if
        end do
        success = .false.
        return
     end do SCAN_ENTRIES
   end subroutine pdg_list_match_replace
 
 @ %def pdg_list_match_replace
 @ Just check if a PDG array matches any entry in the PDG list.  The second
 version returns the position of the match within the list.  An optional mask
 indicates the list elements that should be checked.
 <<PDG arrays: pdg list: TBP>>=
   generic :: operator (.match.) => pdg_list_match_pdg_array
   procedure, private :: pdg_list_match_pdg_array
   procedure :: find_match => pdg_list_find_match_pdg_array
 <<PDG arrays: procedures>>=
   function pdg_list_match_pdg_array (pl, pa) result (flag)
     class(pdg_list_t), intent(in) :: pl
     type(pdg_array_t), intent(in) :: pa
     logical :: flag
     flag = pl%find_match (pa) /= 0
   end function pdg_list_match_pdg_array
 
   function pdg_list_find_match_pdg_array (pl, pa, mask) result (i)
     class(pdg_list_t), intent(in) :: pl
     type(pdg_array_t), intent(in) :: pa
     logical, dimension(:), intent(in), optional :: mask
     integer :: i
     do i = 1, size (pl%a)
        if (present (mask)) then
           if (.not. mask(i))  cycle
        end if
        if (pl%a(i) .match. pa)  return
     end do
     i = 0
   end function pdg_list_find_match_pdg_array
 
 @ %def pdg_list_match_pdg_array
 @ %def pdg_list_find_match_pdg_array
 @ Some old compilers have problems with allocatable arrays as
 intent(out) or as function result, so be conservative here:
 <<PDG arrays: pdg list: TBP>>=
   procedure :: create_pdg_array => pdg_list_create_pdg_array
 <<PDG arrays: procedures>>=
   subroutine pdg_list_create_pdg_array (pl, pdg)
     class(pdg_list_t), intent(in) :: pl
     type(pdg_array_t), dimension(:), intent(inout), allocatable :: pdg
     integer :: n_elements
     integer :: i
     associate (a => pl%a)
       n_elements = size (a)
       if (allocated (pdg))  deallocate (pdg)
       allocate (pdg (n_elements))
       do i = 1, n_elements
          pdg(i) = a(i)
       end do
     end associate
   end subroutine pdg_list_create_pdg_array
 
 @ %def pdg_list_create_pdg_array
 @
 <<PDG arrays: pdg list: TBP>>=
   procedure :: create_antiparticles => pdg_list_create_antiparticles
 <<PDG arrays: procedures>>=
   subroutine pdg_list_create_antiparticles (pl, pl_anti, n_new_particles)
     class(pdg_list_t), intent(in) :: pl
     type(pdg_list_t), intent(out) :: pl_anti
     integer, intent(out) :: n_new_particles
     type(pdg_list_t) :: pl_inverse
     integer :: i, n
     integer :: n_identical
     logical, dimension(:), allocatable :: collect
     n = pl%get_size (); n_identical = 0
     allocate (collect (n)); collect = .true.
     call pl_inverse%init (n)
     do i = 1, n
        pl_inverse%a(i) = pl%a(i)%invert()
     end do
     do i = 1, n
        if (any (pl_inverse%a(i) == pl%a)) then
           collect(i) = .false.
           n_identical = n_identical + 1
        end if
     end do
     n_new_particles = n - n_identical
     if (n_new_particles > 0) then
        call pl_anti%init (n_new_particles)
        do i = 1, n
           if (collect (i)) pl_anti%a(i) = pl_inverse%a(i)
        end do
    end if
   end subroutine pdg_list_create_antiparticles
 
 @ %def pdg_list_create_antiparticles
 @
 <<PDG arrays: pdg list: TBP>>=
   procedure :: search_for_particle => pdg_list_search_for_particle
 <<PDG arrays: procedures>>=
   elemental function pdg_list_search_for_particle (pl, i_part) result (found)
     logical :: found
     class(pdg_list_t), intent(in) :: pl
     integer, intent(in) :: i_part
     integer :: i_pl
     do i_pl = 1, size (pl%a)
        found = pl%a(i_pl)%search_for_particle (i_part)
        if (found)  return
     end do
   end function pdg_list_search_for_particle
 
 @ %def pdg_list_search_for_particle
 @
 <<PDG arrays: pdg list: TBP>>=
   procedure :: contains_colored_particles => pdg_list_contains_colored_particles
 <<PDG arrays: procedures>>=
   function pdg_list_contains_colored_particles (pl) result (colored)
     class(pdg_list_t), intent(in) :: pl
     logical :: colored
     integer :: i
     colored = .false.
     do i = 1, size (pl%a)
        if (pl%a(i)%has_colored_particles()) then
           colored = .true.
           exit
        end if
     end do
   end function pdg_list_contains_colored_particles
 
 @ %def pdg_list_contains_colored_particles
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[pdg_arrays_ut.f90]]>>=
 <<File header>>
 
 module pdg_arrays_ut
   use unit_tests
   use pdg_arrays_uti
 
 <<Standard module head>>
 
 <<PDG arrays: public test>>
 
 contains
 
 <<PDG arrays: test driver>>
 
 end module pdg_arrays_ut
 @ %def pdg_arrays_ut
 @
 <<[[pdg_arrays_uti.f90]]>>=
 <<File header>>
 
 module pdg_arrays_uti
 
   use pdg_arrays
 
 <<Standard module head>>
 
 <<PDG arrays: test declarations>>
 
 contains
 
 <<PDG arrays: tests>>
 
 end module pdg_arrays_uti
 @ %def pdg_arrays_ut
 @ API: driver for the unit tests below.
 <<PDG arrays: public test>>=
   public :: pdg_arrays_test
 <<PDG arrays: test driver>>=
   subroutine pdg_arrays_test (u, results)
     integer, intent(in) :: u
     type (test_results_t), intent(inout) :: results
   <<PDG arrays: execute tests>>
   end subroutine pdg_arrays_test
 
 @ %def pdg_arrays_test
 @ Basic functionality.
 <<PDG arrays: execute tests>>=
   call test (pdg_arrays_1, "pdg_arrays_1", &
        "create and sort PDG array", &
        u, results)
 <<PDG arrays: test declarations>>=
   public :: pdg_arrays_1
 <<PDG arrays: tests>>=
   subroutine pdg_arrays_1 (u)
     integer, intent(in) :: u
 
     type(pdg_array_t) :: pa, pa1, pa2, pa3, pa4, pa5, pa6
     integer, dimension(:), allocatable :: pdg
 
     write (u, "(A)")  "* Test output: pdg_arrays_1"
     write (u, "(A)")  "*   Purpose: create and sort PDG arrays"
     write (u, "(A)")
 
     write (u, "(A)")  "* Assignment"
     write (u, "(A)")
 
     call pa%write (u)
     write (u, *)
     write (u, "(A,I0)")  "length = ", pa%get_length ()
     pdg = pa
     write (u, "(A,3(1x,I0))")  "contents = ", pdg
 
     write (u, *)
     pa = 1
     call pa%write (u)
     write (u, *)
     write (u, "(A,I0)")  "length = ", pa%get_length ()
     pdg = pa
     write (u, "(A,3(1x,I0))")  "contents = ", pdg
 
     write (u, *)
     pa = [1, 2, 3]
     call pa%write (u)
     write (u, *)
     write (u, "(A,I0)")  "length = ", pa%get_length ()
     pdg = pa
     write (u, "(A,3(1x,I0))")  "contents = ", pdg
     write (u, "(A,I0)")  "element #2 = ", pa%get (2)
 
     write (u, *)
     write (u, "(A)")  "* Replace"
     write (u, *)
 
     pa = pa%replace (2, [-5, 5, -7])
     call pa%write (u)
     write (u, *)
 
     write (u, *)
     write (u, "(A)")  "* Sort"
     write (u, *)
 
     pa = [1, -7, 3, -5, 5, 3]
     call pa%write (u)
     write (u, *)
     pa1 = pa%sort_abs ()
     pa2 = pa%sort_abs (unique = .true.)
     call pa1%write (u)
     write (u, *)
     call pa2%write (u)
     write (u, *)
 
     write (u, *)
     write (u, "(A)")  "* Compare"
     write (u, *)
 
     pa1 = [1, 3]
     pa2 = [1, 2, -2]
     pa3 = [1, 2, 4]
     pa4 = [1, 2, 4]
     pa5 = [1, 2, -4]
     pa6 = [1, 2, -3]
 
     write (u, "(A,6(1x,L1))")  "< ", &
          pa1 < pa2, pa2 < pa3, pa3 < pa4, pa4 < pa5, pa5 < pa6, pa6 < pa1
     write (u, "(A,6(1x,L1))")  "> ", &
          pa1 > pa2, pa2 > pa3, pa3 > pa4, pa4 > pa5, pa5 > pa6, pa6 > pa1
     write (u, "(A,6(1x,L1))")  "<=", &
          pa1 <= pa2, pa2 <= pa3, pa3 <= pa4, pa4 <= pa5, pa5 <= pa6, pa6 <= pa1
     write (u, "(A,6(1x,L1))")  ">=", &
          pa1 >= pa2, pa2 >= pa3, pa3 >= pa4, pa4 >= pa5, pa5 >= pa6, pa6 >= pa1
     write (u, "(A,6(1x,L1))")  "==", &
          pa1 == pa2, pa2 == pa3, pa3 == pa4, pa4 == pa5, pa5 == pa6, pa6 == pa1
     write (u, "(A,6(1x,L1))")  "/=", &
          pa1 /= pa2, pa2 /= pa3, pa3 /= pa4, pa4 /= pa5, pa5 /= pa6, pa6 /= pa1
 
     write (u, *)
     pa1 = [0]
     pa2 = [1, 2]
     pa3 = [1, -2]
 
     write (u, "(A,6(1x,L1))")  "eqv ", &
          pa1 .eqv. pa1, pa1 .eqv. pa2, &
          pa2 .eqv. pa2, pa2 .eqv. pa3
 
     write (u, "(A,6(1x,L1))")  "neqv", &
          pa1 .neqv. pa1, pa1 .neqv. pa2, &
          pa2 .neqv. pa2, pa2 .neqv. pa3
 
 
     write (u, *)
     write (u, "(A,6(1x,L1))")  "match", &
          pa1 .match. 0, pa1 .match. 1, &
          pa2 .match. 0, pa2 .match. 1, pa2 .match. 3
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: pdg_arrays_1"
 
   end subroutine pdg_arrays_1
 
 @ %def pdg_arrays_1
 @ PDG array list, i.e., arrays of arrays.
 <<PDG arrays: execute tests>>=
   call test (pdg_arrays_2, "pdg_arrays_2", &
        "create and sort PDG lists", &
        u, results)
 <<PDG arrays: test declarations>>=
   public :: pdg_arrays_2
 <<PDG arrays: tests>>=
   subroutine pdg_arrays_2 (u)
     integer, intent(in) :: u
 
     type(pdg_array_t) :: pa
     type(pdg_list_t) :: pl, pl1
 
     write (u, "(A)")  "* Test output: pdg_arrays_2"
     write (u, "(A)")  "*   Purpose: create and sort PDG lists"
     write (u, "(A)")
 
     write (u, "(A)")  "* Assignment"
     write (u, "(A)")
 
     call pl%init (3)
     call pl%set (1, 42)
     call pl%set (2, [3, 2])
     pa = [5, -5]
     call pl%set (3, pa)
     call pl%write (u)
     write (u, *)
     write (u, "(A,I0)")  "size = ", pl%get_size ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Sort"
     write (u, "(A)")
 
     pl = pl%sort_abs ()
     call pl%write (u)
     write (u, *)
 
     write (u, "(A)")
     write (u, "(A)")  "* Extract item #3"
     write (u, "(A)")
 
     pa = pl%get (3)
     call pa%write (u)
     write (u, *)
 
     write (u, "(A)")
     write (u, "(A)")  "* Replace item #3"
     write (u, "(A)")
 
     call pl1%init (2)
     call pl1%set (1, [2, 4])
     call pl1%set (2, -7)
 
     pl = pl%replace (3, pl1)
     call pl%write (u)
     write (u, *)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: pdg_arrays_2"
 
   end subroutine pdg_arrays_2
 
 @ %def pdg_arrays_2
 @ Check if a (sorted) PDG array lists is regular.  The entries (PDG arrays)
 must not overlap, unless they are identical.
 <<PDG arrays: execute tests>>=
   call test (pdg_arrays_3, "pdg_arrays_3", &
        "check PDG lists", &
        u, results)
 <<PDG arrays: test declarations>>=
   public :: pdg_arrays_3
 <<PDG arrays: tests>>=
   subroutine pdg_arrays_3 (u)
     integer, intent(in) :: u
 
     type(pdg_list_t) :: pl
 
     write (u, "(A)")  "* Test output: pdg_arrays_3"
     write (u, "(A)")  "*   Purpose: check for regular PDG lists"
     write (u, "(A)")
 
     write (u, "(A)")  "* Regular list"
     write (u, "(A)")
 
     call pl%init (4)
     call pl%set (1, [1, 2])
     call pl%set (2, [1, 2])
     call pl%set (3, [5, -5])
     call pl%set (4, 42)
     call pl%write (u)
     write (u, *)
     write (u, "(L1)") pl%is_regular ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Irregular list"
     write (u, "(A)")
 
     call pl%init (4)
     call pl%set (1, [1, 2])
     call pl%set (2, [1, 2])
     call pl%set (3, [2, 5, -5])
     call pl%set (4, 42)
     call pl%write (u)
     write (u, *)
     write (u, "(L1)") pl%is_regular ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: pdg_arrays_3"
 
   end subroutine pdg_arrays_3
 
 @ %def pdg_arrays_3
 @ Compare PDG array lists.  The lists must be regular, i.e., sorted and with
 non-overlapping (or identical) entries.
 <<PDG arrays: execute tests>>=
   call test (pdg_arrays_4, "pdg_arrays_4", &
        "compare PDG lists", &
        u, results)
 <<PDG arrays: test declarations>>=
   public :: pdg_arrays_4
 <<PDG arrays: tests>>=
   subroutine pdg_arrays_4 (u)
     integer, intent(in) :: u
 
     type(pdg_list_t) :: pl1, pl2, pl3
 
     write (u, "(A)")  "* Test output: pdg_arrays_4"
     write (u, "(A)")  "*   Purpose: check for regular PDG lists"
     write (u, "(A)")
 
     write (u, "(A)")  "* Create lists"
     write (u, "(A)")
 
     call pl1%init (4)
     call pl1%set (1, [1, 2])
     call pl1%set (2, [1, 2])
     call pl1%set (3, [5, -5])
     call pl1%set (4, 42)
     write (u, "(I1,1x)", advance = "no")  1
     call pl1%write (u)
     write (u, *)
 
     call pl2%init (2)
     call pl2%set (1, 3)
     call pl2%set (2, [5, -5])
     write (u, "(I1,1x)", advance = "no")  2
     call pl2%write (u)
     write (u, *)
 
     call pl3%init (2)
     call pl3%set (1, 4)
     call pl3%set (2, [5, -5])
     write (u, "(I1,1x)", advance = "no")  3
     call pl3%write (u)
     write (u, *)
 
     write (u, "(A)")
     write (u, "(A)")  "* a == b"
     write (u, "(A)")
 
     write (u, "(2x,A)")  "123"
     write (u, *)
     write (u, "(I1,1x,4L1)")  1, pl1 == pl1, pl1 == pl2, pl1 == pl3
     write (u, "(I1,1x,4L1)")  2, pl2 == pl1, pl2 == pl2, pl2 == pl3
     write (u, "(I1,1x,4L1)")  3, pl3 == pl1, pl3 == pl2, pl3 == pl3
 
     write (u, "(A)")
     write (u, "(A)")  "* a < b"
     write (u, "(A)")
 
     write (u, "(2x,A)")  "123"
     write (u, *)
     write (u, "(I1,1x,4L1)")  1, pl1 < pl1, pl1 < pl2, pl1 < pl3
     write (u, "(I1,1x,4L1)")  2, pl2 < pl1, pl2 < pl2, pl2 < pl3
     write (u, "(I1,1x,4L1)")  3, pl3 < pl1, pl3 < pl2, pl3 < pl3
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: pdg_arrays_4"
 
   end subroutine pdg_arrays_4
 
 @ %def pdg_arrays_4
 @ Match-replace: translate all entries in the first list into the
 matching entries of the second list, if there is a match.
 <<PDG arrays: execute tests>>=
   call test (pdg_arrays_5, "pdg_arrays_5", &
        "match PDG lists", &
        u, results)
 <<PDG arrays: test declarations>>=
   public :: pdg_arrays_5
 <<PDG arrays: tests>>=
   subroutine pdg_arrays_5 (u)
     integer, intent(in) :: u
 
     type(pdg_list_t) :: pl1, pl2, pl3
     logical :: success
 
     write (u, "(A)")  "* Test output: pdg_arrays_5"
     write (u, "(A)")  "*   Purpose: match-replace"
     write (u, "(A)")
 
     write (u, "(A)")  "* Create lists"
     write (u, "(A)")
 
     call pl1%init (2)
     call pl1%set (1, [1, 2])
     call pl1%set (2, 42)
     call pl1%write (u)
     write (u, *)
     call pl3%init (2)
     call pl3%set (1, [42, -42])
     call pl3%set (2, [1, 2, 3, 4])
     call pl1%match_replace (pl3, success)
     call pl3%write (u)
     write (u, "(1x,A,1x,L1,':',1x)", advance="no")  "=>", success
     call pl1%write (u)
     write (u, *)
 
     write (u, *)
 
     call pl2%init (2)
     call pl2%set (1, 9)
     call pl2%set (2, 42)
     call pl2%write (u)
     write (u, *)
     call pl2%match_replace (pl3, success)
     call pl3%write (u)
     write (u, "(1x,A,1x,L1,':',1x)", advance="no")  "=>", success
     call pl2%write (u)
     write (u, *)
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: pdg_arrays_5"
 
   end subroutine pdg_arrays_5
 
 @ %def pdg_arrays_5
 @
 \clearpage
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Jets}
 
 The FastJet library is linked externally, if available.  The wrapper code is
 also in a separate directory.  Here, we define \whizard-specific procedures
 and tests.
 <<[[jets.f90]]>>=
 <<File header>>
 
 module jets
 
   use fastjet !NODEP!
 
 <<Standard module head>>
 
 <<Jets: public>>
 
 contains
 
 <<Jets: procedures>>
 
 end module jets
 @ %def jets
 @
 \subsection{Re-exported symbols}
 We use this module as a proxy for the FastJet interface, therefore we
 re-export some symbols.
 <<Jets: public>>=
   public :: fastjet_available
   public :: fastjet_init
   public :: jet_definition_t
   public :: pseudojet_t
   public :: pseudojet_vector_t
   public :: cluster_sequence_t
   public :: assignment (=)
 
 @ %def jet_definition_t pseudojet_t pseudojet_vector_t cluster_sequence_t
 @ The initialization routine prints the banner.
 <<Jets: procedures>>=
   subroutine fastjet_init ()
     call print_banner ()
   end subroutine fastjet_init
 
 @ %def fastjet_init
 @ The jet algorithm codes (actually, integers)
 <<Jets: public>>=
   public :: kt_algorithm
   public :: cambridge_algorithm
   public :: antikt_algorithm
   public :: genkt_algorithm
   public :: cambridge_for_passive_algorithm
   public :: genkt_for_passive_algorithm
   public :: ee_kt_algorithm
   public :: ee_genkt_algorithm
   public :: plugin_algorithm
   public :: undefined_jet_algorithm
 
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[jets_ut.f90]]>>=
 <<File header>>
 
 module jets_ut
   use unit_tests
   use jets_uti
 
 <<Standard module head>>
 
 <<Jets: public test>>
 
 contains
 
 <<Jets: test driver>>
 
 end module jets_ut
 @ %def jets_ut
 @
 <<[[jets_uti.f90]]>>=
 <<File header>>
 
 module jets_uti
 
 <<Use kinds>>
   use fastjet !NODEP!
 
   use jets
 
 <<Standard module head>>
 
 <<Jets: test declarations>>
 
 contains
 
 <<Jets: tests>>
 
 end module jets_uti
 @ %def jets_ut
 @ API: driver for the unit tests below.
 <<Jets: public test>>=
   public :: jets_test
 <<Jets: test driver>>=
   subroutine jets_test (u, results)
     integer, intent(in) :: u
     type (test_results_t), intent(inout) :: results
   <<Jets: execute tests>>
   end subroutine jets_test
 
 @ %def jets_test
 @ This test is actually the minimal example from the FastJet manual,
 translated to Fortran.
 
 Note that FastJet creates pseudojet vectors, which we mirror in the
 [[pseudojet_vector_t]], but immediately assign to pseudojet arrays.  Without
 automatic finalization available in the compilers, we should avoid this in
 actual code and rather introduce intermediate variables for those objects,
 which we can finalize explicitly.
 <<Jets: execute tests>>=
   call test (jets_1, "jets_1", &
        "basic FastJet functionality", &
        u, results)
 <<Jets: test declarations>>=
   public :: jets_1
 <<Jets: tests>>=
   subroutine jets_1 (u)
     integer, intent(in) :: u
 
     type(pseudojet_t), dimension(:), allocatable :: prt, jets, constituents
     type(jet_definition_t) :: jet_def
     type(cluster_sequence_t) :: cs
 
     integer, parameter :: dp = default
     integer :: i, j
 
     write (u, "(A)")  "* Test output: jets_1"
     write (u, "(A)")  "*   Purpose: test basic FastJet functionality"
     write (u, "(A)")
 
     write (u, "(A)")  "* Print banner"
     call print_banner ()
 
     write (u, *)
     write (u, "(A)")  "* Prepare input particles"
     allocate (prt (3))
     call prt(1)%init ( 99._dp, 0.1_dp, 0._dp, 100._dp)
     call prt(2)%init (  4._dp,-0.1_dp, 0._dp,   5._dp)
     call prt(3)%init (-99._dp, 0._dp,  0._dp,  99._dp)
 
     write (u, *)
     write (u, "(A)")  "* Define jet algorithm"
     call jet_def%init (antikt_algorithm, 0.7_dp)
 
     write (u, *)
     write (u, "(A)")  "* Cluster particles according to jet algorithm"
 
     write (u, *)
     write (u, "(A,A)")  "Clustering with ", jet_def%description ()
     call cs%init (pseudojet_vector (prt), jet_def)
 
     write (u, *)
     write (u, "(A)")  "* Sort output jets"
     jets = sorted_by_pt (cs%inclusive_jets ())
 
     write (u, *)
     write (u, "(A)")  "* Print jet observables and constituents"
     write (u, *)
     write (u, "(4x,3(7x,A3))") "pt", "y", "phi"
     do i = 1, size (jets)
        write (u, "(A,1x,I0,A,3(1x,F9.5))") &
             "jet", i, ":", jets(i)%perp (), jets(i)%rap (), jets(i)%phi ()
        constituents = jets(i)%constituents ()
        do j = 1, size (constituents)
           write (u, "(4x,A,1x,I0,A,F9.5)") &
                "constituent", j, "'s pt:", constituents(j)%perp ()
        end do
        do j = 1, size (constituents)
           call constituents(j)%final ()
        end do
     end do
 
     write (u, *)
     write (u, "(A)")  "* Cleanup"
 
     do i = 1, size (prt)
        call prt(i)%final ()
     end do
     do i = 1, size (jets)
        call jets(i)%final ()
     end do
     call jet_def%final ()
     call cs%final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: jets_1"
 
   end subroutine jets_1
 
 @ %def jets_1
 @
 \clearpage
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Subevents}
 
 The purpose of subevents is to store the relevant part of the physical
 event (either partonic or hadronic), and to hold particle selections
 and combinations which are constructed in cut or analysis expressions.
 <<[[subevents.f90]]>>=
 <<File header>>
 
 module subevents
 
   use, intrinsic :: iso_c_binding !NODEP!
 
 <<Use kinds>>
   use io_units
   use format_defs, only: FMT_14, FMT_19
   use format_utils, only: pac_fmt
   use sorting
   use c_particles
   use lorentz
   use pdg_arrays
   use jets
 
 <<Standard module head>>
 
 <<Subevents: public>>
 
 <<Subevents: parameters>>
 
 <<Subevents: types>>
 
 <<Subevents: interfaces>>
 
 contains
 
 <<Subevents: procedures>>
 
 end module subevents
 @ %def subevents
 @
 \subsection{Particles}
 For the purpose of this module, a particle has a type which can
 indicate a beam, incoming, outgoing, or composite particle, flavor and
 helicity codes (integer, undefined for composite), four-momentum and
 invariant mass squared.  (Other particles types are used in extended
 event types, but also defined here.)  Furthermore, each particle has
 an allocatable array of ancestors -- particle indices which indicate
 the building blocks of a composite particle.  For an incoming/outgoing
 particle, the array contains only the index of the particle itself.
 
 For incoming particles, the momentum is inverted before storing it in
 the particle object.
 <<Subevents: parameters>>=
   integer, parameter, public :: PRT_UNDEFINED = 0
   integer, parameter, public :: PRT_BEAM = -9
   integer, parameter, public :: PRT_INCOMING = 1
   integer, parameter, public :: PRT_OUTGOING = 2
   integer, parameter, public :: PRT_COMPOSITE = 3
   integer, parameter, public :: PRT_VIRTUAL = 4
   integer, parameter, public :: PRT_RESONANT = 5
   integer, parameter, public :: PRT_BEAM_REMNANT = 9
 
 @ %def PRT_UNDEFINED PRT_BEAM
 @ %def PRT_INCOMING PRT_OUTGOING PRT_COMPOSITE
 @ %def PRT_COMPOSITE PRT_VIRTUAL PRT_RESONANT
 @ %def PRT_BEAM_REMNANT
 @
 \subsubsection{The type}
 We initialize only the type here and mark as unpolarized.  The
 initializers below do the rest.
 <<Subevents: public>>=
   public :: prt_t
 <<Subevents: types>>=
   type :: prt_t
      private
      integer :: type = PRT_UNDEFINED
      integer :: pdg
      logical :: polarized = .false.
+     logical :: colorized = .false.
      integer :: h
      type(vector4_t) :: p
      real(default) :: p2
      integer, dimension(:), allocatable :: src
+     integer, dimension(:), allocatable :: col
+     integer, dimension(:), allocatable :: acl
   end type prt_t
 
 @ %def prt_t
 @ Initializers.  Polarization is set separately.  Finalizers are not
 needed.
 <<Subevents: procedures>>=
   subroutine prt_init_beam (prt, pdg, p, p2, src)
     type(prt_t), intent(out) :: prt
     integer, intent(in) :: pdg
     type(vector4_t), intent(in) :: p
     real(default), intent(in) :: p2
     integer, dimension(:), intent(in) :: src
     prt%type = PRT_BEAM
     call prt_set (prt, pdg, - p, p2, src)
   end subroutine prt_init_beam
 
   subroutine prt_init_incoming (prt, pdg, p, p2, src)
     type(prt_t), intent(out) :: prt
     integer, intent(in) :: pdg
     type(vector4_t), intent(in) :: p
     real(default), intent(in) :: p2
     integer, dimension(:), intent(in) :: src
     prt%type = PRT_INCOMING
     call prt_set (prt, pdg, - p, p2, src)
   end subroutine prt_init_incoming
 
   subroutine prt_init_outgoing (prt, pdg, p, p2, src)
     type(prt_t), intent(out) :: prt
     integer, intent(in) :: pdg
     type(vector4_t), intent(in) :: p
     real(default), intent(in) :: p2
     integer, dimension(:), intent(in) :: src
     prt%type = PRT_OUTGOING
     call prt_set (prt, pdg, p, p2, src)
   end subroutine prt_init_outgoing
 
   subroutine prt_init_composite (prt, p, src)
     type(prt_t), intent(out) :: prt
     type(vector4_t), intent(in) :: p
     integer, dimension(:), intent(in) :: src
     prt%type = PRT_COMPOSITE
     call prt_set (prt, 0, p, p**2, src)
   end subroutine prt_init_composite
 
 @ %def prt_init_beam prt_init_incoming prt_init_outgoing prt_init_composite
 @
 This version is for temporary particle objects, so the [[src]] array
 is not set.
 <<Subevents: public>>=
   public :: prt_init_combine
 <<Subevents: procedures>>=
   subroutine prt_init_combine (prt, prt1, prt2)
     type(prt_t), intent(out) :: prt
     type(prt_t), intent(in) :: prt1, prt2
     type(vector4_t) :: p
     integer, dimension(0) :: src
     prt%type = PRT_COMPOSITE
     p = prt1%p + prt2%p
     call prt_set (prt, 0, p, p**2, src)
   end subroutine prt_init_combine
 
 @ %def prt_init_combine
 @ Init from a pseudojet object.
 <<Subevents: procedures>>=
   subroutine prt_init_pseudojet (prt, jet, src, pdg)
     type(prt_t), intent(out) :: prt
     type(pseudojet_t), intent(in) :: jet
     integer, dimension(:), intent(in) :: src
     integer, intent(in) :: pdg
     type(vector4_t) :: p
     prt%type = PRT_COMPOSITE
     p = vector4_moving (jet%e(), &
          vector3_moving ([jet%px(), jet%py(), jet%pz()]))
     call prt_set (prt, pdg, p, p**2, src)
   end subroutine prt_init_pseudojet
 
 @ %def prt_init_pseudojet
 @
 \subsubsection{Accessing contents}
 <<Subevents: public>>=
   public :: prt_get_pdg
 <<Subevents: procedures>>=
   elemental function prt_get_pdg (prt) result (pdg)
     integer :: pdg
     type(prt_t), intent(in) :: prt
     pdg = prt%pdg
   end function prt_get_pdg
 
 @ %def prt_get_pdg
 <<Subevents: public>>=
   public :: prt_get_momentum
 <<Subevents: procedures>>=
   elemental function prt_get_momentum (prt) result (p)
     type(vector4_t) :: p
     type(prt_t), intent(in) :: prt
     p = prt%p
   end function prt_get_momentum
 
 @ %def prt_get_momentum
 <<Subevents: public>>=
   public :: prt_get_msq
 <<Subevents: procedures>>=
   elemental function prt_get_msq (prt) result (msq)
     real(default) :: msq
     type(prt_t), intent(in) :: prt
     msq = prt%p2
   end function prt_get_msq
 
 @ %def prt_get_msq
 <<Subevents: public>>=
   public :: prt_is_polarized
 <<Subevents: procedures>>=
   elemental function prt_is_polarized (prt) result (flag)
     logical :: flag
     type(prt_t), intent(in) :: prt
     flag = prt%polarized
   end function prt_is_polarized
 
 @ %def prt_is_polarized
 <<Subevents: public>>=
   public :: prt_get_helicity
 <<Subevents: procedures>>=
   elemental function prt_get_helicity (prt) result (h)
     integer :: h
     type(prt_t), intent(in) :: prt
     h = prt%h
   end function prt_get_helicity
 
 @ %def prt_get_helicity
+<<Subevents: public>>=
+  public :: prt_is_colorized
+<<Subevents: procedures>>=
+  elemental function prt_is_colorized (prt) result (flag)
+    logical :: flag
+    type(prt_t), intent(in) :: prt
+    flag = prt%colorized
+  end function prt_is_colorized
+
+@ %def prt_is_colorized
+@ The number of open color (anticolor) lines.  We inspect the list of color
+(anticolor) lines and count the entries that do not appear in the list
+of anticolors (colors).  (There is no check against duplicates; we assume that
+color line indices are unique.)
+<<Subevents: public>>=
+  public :: prt_get_n_col
+  public :: prt_get_n_acl
+<<Subevents: procedures>>=
+  elemental function prt_get_n_col (prt) result (n)
+    integer :: n
+    type(prt_t), intent(in) :: prt
+    integer, dimension(:), allocatable :: col, acl
+    integer :: i
+    n = 0
+    if (prt%colorized) then
+       do i = 1, size (prt%col)
+          if (all (prt%col(i) /= prt%acl)) n = n + 1
+       end do
+    end if
+  end function prt_get_n_col
+
+  elemental function prt_get_n_acl (prt) result (n)
+    integer :: n
+    type(prt_t), intent(in) :: prt
+    integer, dimension(:), allocatable :: col, acl
+    integer :: i
+    n = 0
+    if (prt%colorized) then
+       do i = 1, size (prt%acl)
+          if (all (prt%acl(i) /= prt%col)) n = n + 1
+       end do
+    end if
+  end function prt_get_n_acl
+
+@ %def prt_get_n_col
+@ %def prt_get_n_acl
+@ Return the color and anticolor-flow line indices explicitly.
+<<Subevents: public>>=
+  public :: prt_get_color_indices
+<<Subevents: procedures>>=
+  subroutine prt_get_color_indices (prt, col, acl)
+    type(prt_t), intent(in) :: prt
+    integer, dimension(:), allocatable, intent(out) :: col, acl
+    if (prt%colorized) then
+       col = prt%col
+       acl = prt%acl
+    else
+       col = [integer::]
+       acl = [integer::]
+    end if
+  end subroutine prt_get_color_indices
+
+@ %def prt_get_color_indices
 @
 \subsubsection{Setting data}
 Set the PDG, momentum and momentum squared, and ancestors.  If
 allocate-on-assignment is available, this can be simplified.
 <<Subevents: procedures>>=
   subroutine prt_set (prt, pdg, p, p2, src)
     type(prt_t), intent(inout) :: prt
     integer, intent(in) :: pdg
     type(vector4_t), intent(in) :: p
     real(default), intent(in) :: p2
     integer, dimension(:), intent(in) :: src
     prt%pdg = pdg
     prt%p = p
     prt%p2 = p2
     if (allocated (prt%src)) then
        if (size (src) /= size (prt%src)) then
           deallocate (prt%src)
           allocate (prt%src (size (src)))
        end if
     else
        allocate (prt%src (size (src)))
     end if
     prt%src = src
   end subroutine prt_set
 
 @ %def prt_set
 @ Set the particle PDG code separately.
 <<Subevents: procedures>>=
   elemental subroutine prt_set_pdg (prt, pdg)
     type(prt_t), intent(inout) :: prt
     integer, intent(in) :: pdg
     prt%pdg = pdg
   end subroutine prt_set_pdg
 
 @ %def prt_set_pdg
 @ Set the momentum separately.
 <<Subevents: procedures>>=
   elemental subroutine prt_set_p (prt, p)
     type(prt_t), intent(inout) :: prt
     type(vector4_t), intent(in) :: p
     prt%p = p
   end subroutine prt_set_p
 
 @ %def prt_set_p
 @ Set the squared invariant mass separately.
 <<Subevents: procedures>>=
   elemental subroutine prt_set_p2 (prt, p2)
     type(prt_t), intent(inout) :: prt
     real(default), intent(in) :: p2
     prt%p2 = p2
   end subroutine prt_set_p2
 
 @ %def prt_set_p2
 @ Set helicity (optional).
 <<Subevents: procedures>>=
   subroutine prt_polarize (prt, h)
     type(prt_t), intent(inout) :: prt
     integer, intent(in) :: h
     prt%polarized = .true.
     prt%h = h
   end subroutine prt_polarize
 
 @ %def prt_polarize
+@ Set color-flow indices (optional).
+<<Subevents: procedures>>=
+  subroutine prt_colorize (prt, col, acl)
+    type(prt_t), intent(inout) :: prt
+    integer, dimension(:), intent(in) :: col, acl
+    prt%colorized = .true.
+    prt%col = col
+    prt%acl = acl
+  end subroutine prt_colorize
+
+@ %def prt_colorize
 @
 \subsubsection{Conversion}
 Transform a [[prt_t]] object into a [[c_prt_t]] object.
 <<Subevents: public>>=
   public :: c_prt
 <<Subevents: interfaces>>=
   interface c_prt
      module procedure c_prt_from_prt
   end interface
 
 @ %def c_prt
 <<Subevents: procedures>>=
   elemental function c_prt_from_prt (prt) result (c_prt)
     type(c_prt_t) :: c_prt
     type(prt_t), intent(in) :: prt
     c_prt = prt%p
     c_prt%type = prt%type
     c_prt%pdg = prt%pdg
     if (prt%polarized) then
        c_prt%polarized = 1
     else
        c_prt%polarized = 0
     end if
     c_prt%h = prt%h
   end function c_prt_from_prt
 
 @ %def c_prt_from_prt
 @
 \subsubsection{Output}
 <<Subevents: public>>=
   public :: prt_write
 <<Subevents: procedures>>=
   subroutine prt_write (prt, unit, testflag)
     type(prt_t), intent(in) :: prt
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: testflag
     logical :: pacified
     type(prt_t) :: tmp
     character(len=7) :: fmt
     integer :: u, i
     call pac_fmt (fmt, FMT_19, FMT_14, testflag)
     u = given_output_unit (unit);  if (u < 0)  return
     pacified = .false. ; if (present (testflag))  pacified = testflag
     tmp = prt
     if (pacified) call pacify (tmp)
     write (u, "(1x,A)", advance="no")  "prt("
     select case (prt%type)
     case (PRT_UNDEFINED);    write (u, "('?')", advance="no")
     case (PRT_BEAM);         write (u, "('b:')", advance="no")
     case (PRT_INCOMING);     write (u, "('i:')", advance="no")
     case (PRT_OUTGOING);     write (u, "('o:')", advance="no")
     case (PRT_COMPOSITE);    write (u, "('c:')", advance="no")
     end select
     select case (prt%type)
     case (PRT_BEAM, PRT_INCOMING, PRT_OUTGOING)
        if (prt%polarized) then
           write (u, "(I0,'/',I0,'|')", advance="no")  prt%pdg, prt%h
        else
           write (u, "(I0,'|')", advance="no") prt%pdg
        end if
     end select
     select case (prt%type)
     case (PRT_BEAM, PRT_INCOMING, PRT_OUTGOING, PRT_COMPOSITE)
+       if (prt%colorized) then
+          write (u, "(*(I0,:,','))", advance="no")  prt%col
+          write (u, "('/')", advance="no")
+          write (u, "(*(I0,:,','))", advance="no")  prt%acl
+          write (u, "('|')", advance="no")
+       end if
+    end select
+    select case (prt%type)
+    case (PRT_BEAM, PRT_INCOMING, PRT_OUTGOING, PRT_COMPOSITE)
        write (u, "(" // FMT_14 // ",';'," // FMT_14 // ",','," // &
             FMT_14 // ",','," // FMT_14 // ")", advance="no") tmp%p
        write (u, "('|'," // fmt // ")", advance="no") tmp%p2
     end select
     if (allocated (prt%src)) then
        write (u, "('|')", advance="no")
        do i = 1, size (prt%src)
           write (u, "(1x,I0)", advance="no")  prt%src(i)
        end do
     end if
     write (u, "(A)")  ")"
   end subroutine prt_write
 
 @ %def prt_write
 @
 \subsubsection{Tools}
 Two particles match if their [[src]] arrays are the same.
 <<Subevents: interfaces>>=
   interface operator(.match.)
      module procedure prt_match
   end interface
 
 @ %def .match.
 <<Subevents: procedures>>=
   elemental function prt_match (prt1, prt2) result (match)
     logical :: match
     type(prt_t), intent(in) :: prt1, prt2
     if (size (prt1%src) == size (prt2%src)) then
        match = all (prt1%src == prt2%src)
     else
        match = .false.
     end if
   end function prt_match
 
 @ %def prt_match
 @ The combine operation makes a pseudoparticle whose momentum is the
 result of adding (the momenta of) the pair of input particles.  We
 trace the particles from which a particle is built by storing a
 [[src]] array.  Each particle entry in the [[src]] list contains a
 list of indices which indicates its building blocks.  The indices
 refer to an original list of particles.  Index lists are sorted, and
 they contain no element more than once.
 
 We thus require that in a given pseudoparticle, each original particle
 occurs at most once.
 
 The result is intent(inout), so it will not be initialized when the
 subroutine is entered.
+
+If the particles carry color, we recall that the combined particle is a
+composite which is understood as outgoing.  If one of the arguments is an
+incoming particle, is color entries must be reversed.
 <<Subevents: procedures>>=
   subroutine prt_combine (prt, prt_in1, prt_in2, ok)
     type(prt_t), intent(inout) :: prt
     type(prt_t), intent(in) :: prt_in1, prt_in2
     logical :: ok
     integer, dimension(:), allocatable :: src
+    integer, dimension(:), allocatable :: col1, acl1, col2, acl2
     call combine_index_lists (src, prt_in1%src, prt_in2%src)
     ok = allocated (src)
-    if (ok)  call prt_init_composite (prt, prt_in1%p + prt_in2%p, src)
+    if (ok) then
+       call prt_init_composite (prt, prt_in1%p + prt_in2%p, src)
+       if (prt_in1%colorized .or. prt_in2%colorized) then
+          select case (prt_in1%type)
+          case default
+             call prt_get_color_indices (prt_in1, col1, acl1)
+          case (PRT_BEAM, PRT_INCOMING)
+             call prt_get_color_indices (prt_in1, acl1, col1)
+          end select
+          select case (prt_in2%type)
+          case default
+             call prt_get_color_indices (prt_in2, col2, acl2)
+          case (PRT_BEAM, PRT_INCOMING)
+             call prt_get_color_indices (prt_in2, acl2, col2)
+          end select
+          call prt_colorize (prt, [col1, col2], [acl1, acl2])
+       end if
+    end if
   end subroutine prt_combine
 
 @ %def prt_combine
 @ This variant does not produce the combined particle, it just checks
 whether the combination is valid (no common [[src]] entry).
 <<Subevents: public>>=
   public :: are_disjoint
 <<Subevents: procedures>>=
   function are_disjoint (prt_in1, prt_in2) result (flag)
     logical :: flag
     type(prt_t), intent(in) :: prt_in1, prt_in2
     flag = index_lists_are_disjoint (prt_in1%src, prt_in2%src)
   end function are_disjoint
 
 @ %def are_disjoint
 @ [[src]] Lists with length $>1$ are built by a [[combine]] operation
 which merges the lists in a sorted manner.  If the result would have a
 duplicate entry, it is discarded, and the result is unallocated.
 <<Subevents: procedures>>=
   subroutine combine_index_lists (res, src1, src2)
     integer, dimension(:), intent(in) :: src1, src2
     integer, dimension(:), allocatable :: res
     integer :: i1, i2, i
     allocate (res (size (src1) + size (src2)))
     if (size (src1) == 0) then
        res = src2
        return
     else if (size (src2) == 0) then
        res = src1
        return
     end if
     i1 = 1
     i2 = 1
     LOOP: do i = 1, size (res)
        if (src1(i1) < src2(i2)) then
           res(i) = src1(i1);  i1 = i1 + 1
           if (i1 > size (src1)) then
              res(i+1:) = src2(i2:)
              exit LOOP
           end if
        else if (src1(i1) > src2(i2)) then
           res(i) = src2(i2);  i2 = i2 + 1
           if (i2 > size (src2)) then
              res(i+1:) = src1(i1:)
              exit LOOP
           end if
        else
           deallocate (res)
           exit LOOP
        end if
     end do LOOP
   end subroutine combine_index_lists
 
 @ %def combine_index_lists
 @ This function is similar, but it does not actually merge the list,
 it just checks whether they are disjoint (no common [[src]] entry).
 <<Subevents: procedures>>=
   function index_lists_are_disjoint (src1, src2) result (flag)
     logical :: flag
     integer, dimension(:), intent(in) :: src1, src2
     integer :: i1, i2, i
     flag = .true.
     i1 = 1
     i2 = 1
     LOOP: do i = 1, size (src1) + size (src2)
        if (src1(i1) < src2(i2)) then
           i1 = i1 + 1
           if (i1 > size (src1)) then
              exit LOOP
           end if
        else if (src1(i1) > src2(i2)) then
           i2 = i2 + 1
           if (i2 > size (src2)) then
              exit LOOP
           end if
        else
           flag = .false.
           exit LOOP
        end if
     end do LOOP
   end function index_lists_are_disjoint
 
 @ %def index_lists_are_disjoint
 @
 \subsection{subevents}
 Particles are collected in subevents.  This type is implemented as a
 dynamically allocated array, which need not be completely filled.  The
 value [[n_active]] determines the number of meaningful entries.
 
 \subsubsection{Type definition}
 <<Subevents: public>>=
   public :: subevt_t
 <<Subevents: types>>=
   type :: subevt_t
      private
      integer :: n_active = 0
      type(prt_t), dimension(:), allocatable :: prt
    contains
    <<Subevents: subevt: TBP>>
   end type subevt_t
 
 @ %def subevt_t
 @ Initialize, allocating with size zero (default) or given size.  The
 number of contained particles is set equal to the size.
 <<Subevents: public>>=
   public :: subevt_init
 <<Subevents: procedures>>=
   subroutine subevt_init (subevt, n_active)
     type(subevt_t), intent(out) :: subevt
     integer, intent(in), optional :: n_active
     if (present (n_active))  subevt%n_active = n_active
     allocate (subevt%prt (subevt%n_active))
   end subroutine subevt_init
 
 @ %def subevt_init
 @ (Re-)allocate the subevent with some given size.  If the size
 is greater than the previous one, do a real reallocation.  Otherwise,
 just reset the recorded size. Contents are untouched, but become
 invalid.
 <<Subevents: public>>=
   public :: subevt_reset
 <<Subevents: procedures>>=
   subroutine subevt_reset (subevt, n_active)
     type(subevt_t), intent(inout) :: subevt
     integer, intent(in) :: n_active
     subevt%n_active = n_active
     if (subevt%n_active > size (subevt%prt)) then
        deallocate (subevt%prt)
        allocate (subevt%prt (subevt%n_active))
     end if
   end subroutine subevt_reset
 
 @ %def subevt_reset
 @ Output.  No prefix for the headline 'subevt', because this will usually be
 printed appending to a previous line.
 <<Subevents: public>>=
   public :: subevt_write
 <<Subevents: subevt: TBP>>=
   procedure :: write => subevt_write
 <<Subevents: procedures>>=
   subroutine subevt_write (object, unit, prefix, pacified)
     class(subevt_t), intent(in) :: object
     integer, intent(in), optional :: unit
     character(*), intent(in), optional :: prefix
     logical, intent(in), optional :: pacified
     integer :: u, i
     u = given_output_unit (unit);  if (u < 0)  return
     write (u, "(1x,A)") "subevent:"
     do i = 1, object%n_active
        if (present (prefix))  write (u, "(A)", advance="no") prefix
        write (u, "(1x,I0)", advance="no")  i
        call prt_write (object%prt(i), unit = unit, testflag = pacified)
     end do
   end subroutine subevt_write
 
 @ %def subevt_write
 @ Defined assignment: transfer only meaningful entries.  This is a
 deep copy (as would be default assignment).
 <<Subevents: interfaces>>=
   interface assignment(=)
      module procedure subevt_assign
   end interface
 
 @ %def =
 <<Subevents: procedures>>=
   subroutine subevt_assign (subevt, subevt_in)
     type(subevt_t), intent(inout) :: subevt
     type(subevt_t), intent(in) :: subevt_in
     if (.not. allocated (subevt%prt)) then
        call subevt_init (subevt, subevt_in%n_active)
     else
        call subevt_reset (subevt, subevt_in%n_active)
     end if
     subevt%prt(:subevt%n_active) = subevt_in%prt(:subevt%n_active)
   end subroutine subevt_assign
 
 @ %def subevt_assign
 @
 \subsubsection{Fill contents}
 Store incoming/outgoing particles which are completely defined.
 <<Subevents: public>>=
   public :: subevt_set_beam
   public :: subevt_set_incoming
   public :: subevt_set_outgoing
   public :: subevt_set_composite
 <<Subevents: procedures>>=
   subroutine subevt_set_beam (subevt, i, pdg, p, p2, src)
     type(subevt_t), intent(inout) :: subevt
     integer, intent(in) :: i
     integer, intent(in) :: pdg
     type(vector4_t), intent(in) :: p
     real(default), intent(in) :: p2
     integer, dimension(:), intent(in), optional :: src
     if (present (src)) then
        call prt_init_beam (subevt%prt(i), pdg, p, p2, src)
     else
        call prt_init_beam (subevt%prt(i), pdg, p, p2, [i])
     end if
   end subroutine subevt_set_beam
 
   subroutine subevt_set_incoming (subevt, i, pdg, p, p2, src)
     type(subevt_t), intent(inout) :: subevt
     integer, intent(in) :: i
     integer, intent(in) :: pdg
     type(vector4_t), intent(in) :: p
     real(default), intent(in) :: p2
     integer, dimension(:), intent(in), optional :: src
     if (present (src)) then
        call prt_init_incoming (subevt%prt(i), pdg, p, p2, src)
     else
        call prt_init_incoming (subevt%prt(i), pdg, p, p2, [i])
     end if
   end subroutine subevt_set_incoming
 
   subroutine subevt_set_outgoing (subevt, i, pdg, p, p2, src)
     type(subevt_t), intent(inout) :: subevt
     integer, intent(in) :: i
     integer, intent(in) :: pdg
     type(vector4_t), intent(in) :: p
     real(default), intent(in) :: p2
     integer, dimension(:), intent(in), optional :: src
     if (present (src)) then
        call prt_init_outgoing (subevt%prt(i), pdg, p, p2, src)
     else
        call prt_init_outgoing (subevt%prt(i), pdg, p, p2, [i])
     end if
   end subroutine subevt_set_outgoing
 
   subroutine subevt_set_composite (subevt, i, p, src)
     type(subevt_t), intent(inout) :: subevt
     integer, intent(in) :: i
     type(vector4_t), intent(in) :: p
     integer, dimension(:), intent(in) :: src
     call prt_init_composite (subevt%prt(i), p, src)
   end subroutine subevt_set_composite
 
 @ %def subevt_set_incoming subevt_set_outgoing subevt_set_composite
 @ Separately assign flavors, simultaneously for all incoming/outgoing
 particles.
 <<Subevents: public>>=
   public :: subevt_set_pdg_beam
   public :: subevt_set_pdg_incoming
   public :: subevt_set_pdg_outgoing
 <<Subevents: procedures>>=
   subroutine subevt_set_pdg_beam (subevt, pdg)
     type(subevt_t), intent(inout) :: subevt
     integer, dimension(:), intent(in) :: pdg
     integer :: i, j
     j = 1
     do i = 1, subevt%n_active
        if (subevt%prt(i)%type == PRT_BEAM) then
           call prt_set_pdg (subevt%prt(i), pdg(j))
           j = j + 1
           if (j > size (pdg))  exit
        end if
     end do
   end subroutine subevt_set_pdg_beam
 
   subroutine subevt_set_pdg_incoming (subevt, pdg)
     type(subevt_t), intent(inout) :: subevt
     integer, dimension(:), intent(in) :: pdg
     integer :: i, j
     j = 1
     do i = 1, subevt%n_active
        if (subevt%prt(i)%type == PRT_INCOMING) then
           call prt_set_pdg (subevt%prt(i), pdg(j))
           j = j + 1
           if (j > size (pdg))  exit
        end if
     end do
   end subroutine subevt_set_pdg_incoming
 
   subroutine subevt_set_pdg_outgoing (subevt, pdg)
     type(subevt_t), intent(inout) :: subevt
     integer, dimension(:), intent(in) :: pdg
     integer :: i, j
     j = 1
     do i = 1, subevt%n_active
        if (subevt%prt(i)%type == PRT_OUTGOING) then
           call prt_set_pdg (subevt%prt(i), pdg(j))
           j = j + 1
           if (j > size (pdg))  exit
        end if
     end do
   end subroutine subevt_set_pdg_outgoing
 
 @ %def subevt_set_pdg_beam
 @ %def subevt_set_pdg_incoming
 @ %def subevt_set_pdg_outgoing
 @ Separately assign momenta, simultaneously for all incoming/outgoing
 particles.
 <<Subevents: public>>=
   public :: subevt_set_p_beam
   public :: subevt_set_p_incoming
   public :: subevt_set_p_outgoing
 <<Subevents: procedures>>=
   subroutine subevt_set_p_beam (subevt, p)
     type(subevt_t), intent(inout) :: subevt
     type(vector4_t), dimension(:), intent(in) :: p
     integer :: i, j
     j = 1
     do i = 1, subevt%n_active
        if (subevt%prt(i)%type == PRT_BEAM) then
           call prt_set_p (subevt%prt(i), p(j))
           j = j + 1
           if (j > size (p))  exit
        end if
     end do
   end subroutine subevt_set_p_beam
 
   subroutine subevt_set_p_incoming (subevt, p)
     type(subevt_t), intent(inout) :: subevt
     type(vector4_t), dimension(:), intent(in) :: p
     integer :: i, j
     j = 1
     do i = 1, subevt%n_active
        if (subevt%prt(i)%type == PRT_INCOMING) then
           call prt_set_p (subevt%prt(i), p(j))
           j = j + 1
           if (j > size (p))  exit
        end if
     end do
   end subroutine subevt_set_p_incoming
 
   subroutine subevt_set_p_outgoing (subevt, p)
     type(subevt_t), intent(inout) :: subevt
     type(vector4_t), dimension(:), intent(in) :: p
     integer :: i, j
     j = 1
     do i = 1, subevt%n_active
        if (subevt%prt(i)%type == PRT_OUTGOING) then
           call prt_set_p (subevt%prt(i), p(j))
           j = j + 1
           if (j > size (p))  exit
        end if
     end do
   end subroutine subevt_set_p_outgoing
 
 @ %def subevt_set_p_beam
 @ %def subevt_set_p_incoming
 @ %def subevt_set_p_outgoing
 @ Separately assign the squared invariant mass, simultaneously for all
 incoming/outgoing particles.
 <<Subevents: public>>=
   public :: subevt_set_p2_beam
   public :: subevt_set_p2_incoming
   public :: subevt_set_p2_outgoing
 <<Subevents: procedures>>=
   subroutine subevt_set_p2_beam (subevt, p2)
     type(subevt_t), intent(inout) :: subevt
     real(default), dimension(:), intent(in) :: p2
     integer :: i, j
     j = 1
     do i = 1, subevt%n_active
        if (subevt%prt(i)%type == PRT_BEAM) then
           call prt_set_p2 (subevt%prt(i), p2(j))
           j = j + 1
           if (j > size (p2))  exit
        end if
     end do
   end subroutine subevt_set_p2_beam
 
   subroutine subevt_set_p2_incoming (subevt, p2)
     type(subevt_t), intent(inout) :: subevt
     real(default), dimension(:), intent(in) :: p2
     integer :: i, j
     j = 1
     do i = 1, subevt%n_active
        if (subevt%prt(i)%type == PRT_INCOMING) then
           call prt_set_p2 (subevt%prt(i), p2(j))
           j = j + 1
           if (j > size (p2))  exit
        end if
     end do
   end subroutine subevt_set_p2_incoming
 
   subroutine subevt_set_p2_outgoing (subevt, p2)
     type(subevt_t), intent(inout) :: subevt
     real(default), dimension(:), intent(in) :: p2
     integer :: i, j
     j = 1
     do i = 1, subevt%n_active
        if (subevt%prt(i)%type == PRT_OUTGOING) then
           call prt_set_p2 (subevt%prt(i), p2(j))
           j = j + 1
           if (j > size (p2))  exit
        end if
     end do
   end subroutine subevt_set_p2_outgoing
 
 @ %def subevt_set_p2_beam
 @ %def subevt_set_p2_incoming
 @ %def subevt_set_p2_outgoing
 @ Set polarization for an entry
 <<Subevents: public>>=
   public :: subevt_polarize
 <<Subevents: procedures>>=
   subroutine subevt_polarize (subevt, i, h)
     type(subevt_t), intent(inout) :: subevt
     integer, intent(in) :: i, h
     call prt_polarize (subevt%prt(i), h)
   end subroutine subevt_polarize
 
 @ %def subevt_polarize
+@ Set color-flow indices for an entry
+<<Subevents: public>>=
+  public :: subevt_colorize
+<<Subevents: procedures>>=
+  subroutine subevt_colorize (subevt, i, col, acl)
+    type(subevt_t), intent(inout) :: subevt
+    integer, intent(in) :: i, col, acl
+    if (col > 0 .and. acl > 0) then
+       call prt_colorize (subevt%prt(i), [col], [acl])
+    else if (col > 0) then
+       call prt_colorize (subevt%prt(i), [col], [integer ::])
+    else if (acl > 0) then
+       call prt_colorize (subevt%prt(i), [integer ::], [acl])
+    else
+       call prt_colorize (subevt%prt(i), [integer ::], [integer ::])
+    end if
+  end subroutine subevt_colorize
+
+@ %def subevt_colorize
 @
 \subsubsection{Accessing contents}
 Return true if the subevent has entries.
 <<Subevents: public>>=
   public :: subevt_is_nonempty
 <<Subevents: procedures>>=
   function subevt_is_nonempty (subevt) result (flag)
     logical :: flag
     type(subevt_t), intent(in) :: subevt
     flag = subevt%n_active /= 0
   end function subevt_is_nonempty
 
 @ %def subevt_is_nonempty
 @ Return the number of entries
 <<Subevents: public>>=
   public :: subevt_get_length
 <<Subevents: procedures>>=
   function subevt_get_length (subevt) result (length)
     integer :: length
     type(subevt_t), intent(in) :: subevt
     length = subevt%n_active
   end function subevt_get_length
 
 @ %def subevt_get_length
 @ Return a specific particle.  The index is not checked for validity.
 <<Subevents: public>>=
   public :: subevt_get_prt
 <<Subevents: procedures>>=
   function subevt_get_prt (subevt, i) result (prt)
     type(prt_t) :: prt
     type(subevt_t), intent(in) :: subevt
     integer, intent(in) :: i
     prt = subevt%prt(i)
   end function subevt_get_prt
 
 @ %def subevt_get_prt
 @ Return the partonic energy squared.  We take the particles with flag
 [[PRT_INCOMING]] and compute their total invariant mass.
 <<Subevents: public>>=
   public :: subevt_get_sqrts_hat
 <<Subevents: procedures>>=
   function subevt_get_sqrts_hat (subevt) result (sqrts_hat)
     type(subevt_t), intent(in) :: subevt
     real(default) :: sqrts_hat
     type(vector4_t) :: p
     integer :: i
     do i = 1, subevt%n_active
        if (subevt%prt(i)%type == PRT_INCOMING) then
           p = p + prt_get_momentum (subevt%prt(i))
        end if
     end do
     sqrts_hat = p ** 1
   end function subevt_get_sqrts_hat
 
 @ %def subevt_get_sqrts_hat
 @ Return the number of incoming (outgoing) particles, respectively.
 Beam particles or composites are not counted.
 <<Subevents: public>>=
   public :: subevt_get_n_in
   public :: subevt_get_n_out
 <<Subevents: procedures>>=
   function subevt_get_n_in (subevt) result (n_in)
     type(subevt_t), intent(in) :: subevt
     integer :: n_in
     n_in = count (subevt%prt(:subevt%n_active)%type == PRT_INCOMING)
   end function subevt_get_n_in
 
   function subevt_get_n_out (subevt) result (n_out)
     type(subevt_t), intent(in) :: subevt
     integer :: n_out
     n_out = count (subevt%prt(:subevt%n_active)%type == PRT_OUTGOING)
   end function subevt_get_n_out
 
 @ %def subevt_get_n_in
 @ %def subevt_get_n_out
 @
 <<Subevents: interfaces>>=
   interface c_prt
      module procedure c_prt_from_subevt
      module procedure c_prt_array_from_subevt
   end interface
 
 @ %def c_prt
 <<Subevents: procedures>>=
   function c_prt_from_subevt (subevt, i) result (c_prt)
     type(c_prt_t) :: c_prt
     type(subevt_t), intent(in) :: subevt
     integer, intent(in) :: i
     c_prt = c_prt_from_prt (subevt%prt(i))
   end function c_prt_from_subevt
 
   function c_prt_array_from_subevt (subevt) result (c_prt_array)
     type(subevt_t), intent(in) :: subevt
     type(c_prt_t), dimension(subevt%n_active) :: c_prt_array
     c_prt_array = c_prt_from_prt (subevt%prt(1:subevt%n_active))
   end function c_prt_array_from_subevt
 
 @ %def c_prt_from_subevt
 @ %def c_prt_array_from_subevt
 @
 \subsubsection{Operations with subevents}
 The join operation joins two subevents.  When appending the
 elements of the second list, we check for each particle whether it is
 already in the first list.  If yes, it is discarded.  The result list
 should be initialized already.
 
 If a mask is present, it refers to the second subevent.
 Particles where the mask is not set are discarded.
 <<Subevents: public>>=
   public :: subevt_join
 <<Subevents: procedures>>=
   subroutine subevt_join (subevt, pl1, pl2, mask2)
     type(subevt_t), intent(inout) :: subevt
     type(subevt_t), intent(in) :: pl1, pl2
     logical, dimension(:), intent(in), optional :: mask2
     integer :: n1, n2, i, n
     n1 = pl1%n_active
     n2 = pl2%n_active
     call subevt_reset (subevt, n1 + n2)
     subevt%prt(:n1)   = pl1%prt(:n1)
     n = n1
     if (present (mask2)) then
        do i = 1, pl2%n_active
           if (mask2(i)) then
              if (disjoint (i)) then
                 n = n + 1
                 subevt%prt(n) = pl2%prt(i)
              end if
           end if
        end do
     else
        do i = 1, pl2%n_active
           if (disjoint (i)) then
              n = n + 1
              subevt%prt(n) = pl2%prt(i)
           end if
        end do
     end if
     subevt%n_active = n
   contains
     function disjoint (i) result (flag)
       integer, intent(in) :: i
       logical :: flag
       integer :: j
       do j = 1, pl1%n_active
          if (.not. are_disjoint (pl1%prt(j), pl2%prt(i))) then
             flag = .false.
             return
          end if
       end do
       flag = .true.
     end function disjoint
   end subroutine subevt_join
 
 @ %def subevt_join
 @ The combine operation makes a subevent whose entries are the
 result of adding (the momenta of) each pair of particles in the input
 lists.  We trace the particles from which a particles is built by
 storing a [[src]] array.  Each particle entry in the [[src]] list
 contains a list of indices which indicates its building blocks.  The
 indices refer to an original list of particles.  Index lists are sorted,
 and they contain no element more than once.
 
 We thus require that in a given pseudoparticle, each original particle
 occurs at most once.
 <<Subevents: public>>=
   public :: subevt_combine
 <<Subevents: procedures>>=
   subroutine subevt_combine (subevt, pl1, pl2, mask12)
     type(subevt_t), intent(inout) :: subevt
     type(subevt_t), intent(in) :: pl1, pl2
     logical, dimension(:,:), intent(in), optional :: mask12
     integer :: n1, n2, i1, i2, n, j
     logical :: ok
     n1 = pl1%n_active
     n2 = pl2%n_active
     call subevt_reset (subevt, n1 * n2)
     n = 1
     do i1 = 1, n1
        do i2 = 1, n2
           if (present (mask12)) then
              ok = mask12(i1,i2)
           else
              ok = .true.
           end if
           if (ok)  call prt_combine &
                (subevt%prt(n), pl1%prt(i1), pl2%prt(i2), ok)
           if (ok) then
              CHECK_DOUBLES: do j = 1, n - 1
                 if (subevt%prt(n) .match. subevt%prt(j)) then
                    ok = .false.;  exit CHECK_DOUBLES
                 end if
              end do CHECK_DOUBLES
              if (ok)  n = n + 1
           end if
        end do
     end do
     subevt%n_active = n - 1
   end subroutine subevt_combine
 
 @ %def subevt_combine
 @ The collect operation makes a single-entry subevent which
 results from combining (the momenta of) all particles in the input
 list.  As above, the result does not contain an original particle more
 than once; this is checked for each particle when it is collected.
 Furthermore, each entry has a mask; where the mask is false, the entry
 is dropped.
 
 (Thus, if the input particles are already composite, there is some
 chance that the result depends on the order of the input list and is
 not as expected.  This situation should be avoided.)
 <<Subevents: public>>=
   public :: subevt_collect
 <<Subevents: procedures>>=
   subroutine subevt_collect (subevt, pl1, mask1)
     type(subevt_t), intent(inout) :: subevt
     type(subevt_t), intent(in) :: pl1
     logical, dimension(:), intent(in) :: mask1
     type(prt_t) :: prt
     integer :: i
     logical :: ok
     call subevt_reset (subevt, 1)
     subevt%n_active = 0
     do i = 1, pl1%n_active
        if (mask1(i)) then
           if (subevt%n_active == 0) then
              subevt%n_active = 1
              subevt%prt(1) = pl1%prt(i)
           else
              call prt_combine (prt, subevt%prt(1), pl1%prt(i), ok)
              if (ok)  subevt%prt(1) = prt
           end if
        end if
     end do
   end subroutine subevt_collect
 
 @ %def subevt_collect
 @ The cluster operation is similar to [[collect]], but applies a jet
 algorithm.  The result is a subevent consisting of jets and, possibly,
 unclustered extra particles.  As above, the result does not contain an
 original particle more than once; this is checked for each particle when it is
 collected.  Furthermore, each entry has a mask; where the mask is false, the
 entry is dropped.
 
 The algorithm: first determine the (pseudo)particles that participate in the
 clustering.  They should not overlap, and the mask entry must be set.  We then
 cluster the particles, using the given jet definition.  The result particles are
 retrieved from the cluster sequence.  We still have to determine the source
 indices for each jet: for each input particle, we get the jet index.
 Accumulating the source entries for all particles that are part of a given
 jet, we derive the jet source entries.  Finally, we delete the C structures
 that have been constructed by FastJet and its interface.
 <<Subevents: public>>=
   public :: subevt_cluster
 <<Subevents: procedures>>=
   subroutine subevt_cluster (subevt, pl1, mask1, jet_def, keep_jets)
     type(subevt_t), intent(inout) :: subevt
     type(subevt_t), intent(in) :: pl1
     logical, dimension(:), intent(in) :: mask1
     type(jet_definition_t), intent(in) :: jet_def
     logical, intent(in) :: keep_jets
     integer, dimension(:), allocatable :: map, jet_index
     type(pseudojet_t), dimension(:), allocatable :: jet_in, jet_out
     type(pseudojet_vector_t) :: jv_in, jv_out
     type(cluster_sequence_t) :: cs
     integer :: i, n_src, n_active
     call map_prt_index (pl1, mask1, n_src, map)
     n_active = count (map /= 0)
     allocate (jet_in (n_active))
     allocate (jet_index (n_active))
     do i = 1, n_active
        call jet_in(i)%init (prt_get_momentum (pl1%prt(map(i))))
     end do
     call jv_in%init (jet_in)
     call cs%init (jv_in, jet_def)
     jv_out = cs%inclusive_jets ()
     call cs%assign_jet_indices (jv_out, jet_index)
     allocate (jet_out (jv_out%size ()))
     jet_out = jv_out
     call fill_pseudojet (subevt, pl1, jet_out, jet_index, n_src, map)
     do i = 1, size (jet_out)
        call jet_out(i)%final ()
     end do
     call jv_out%final ()
     call cs%final ()
     call jv_in%final ()
     do i = 1, size (jet_in)
        call jet_in(i)%final ()
     end do
   contains
     ! Uniquely combine sources and add map those new indices to the old ones
     subroutine map_prt_index (pl1, mask1, n_src, map)
       type(subevt_t), intent(in) :: pl1
       logical, dimension(:), intent(in) :: mask1
       integer, intent(out) :: n_src
       integer, dimension(:), allocatable, intent(out) :: map
       integer, dimension(:), allocatable :: src, src_tmp
       integer :: i
       allocate (src(0))
       allocate (map (pl1%n_active), source = 0)
       n_active = 0
       do i = 1, pl1%n_active
          if (.not. mask1(i)) cycle
          call combine_index_lists (src_tmp, src, pl1%prt(i)%src)
          if (.not. allocated (src_tmp)) cycle
          call move_alloc (from=src_tmp, to=src)
          n_active = n_active + 1
          map(n_active) = i
       end do
       n_src = size (src)
     end subroutine map_prt_index
     ! Retrieve source(s) of a jet and fill corresponding subevent
     subroutine fill_pseudojet (subevt, pl1, jet_out, jet_index, n_src, map)
       type(subevt_t), intent(inout) :: subevt
       type(subevt_t), intent(in) :: pl1
       type(pseudojet_t), dimension(:), intent(in) :: jet_out
       integer, dimension(:), intent(in) :: jet_index
       integer, dimension(:), intent(in) :: map
       integer, intent(in) :: n_src
       integer, dimension(n_src) :: src_fill
       integer :: i, jet, k, combined_pdg, pdg, n_quarks, n_src_fill
       call subevt_reset (subevt, size (jet_out))
       do jet = 1, size (jet_out)
          pdg = 0; src_fill = 0; n_src_fill = 0; combined_pdg = 0; n_quarks = 0
          PARTICLE: do i = 1, size (jet_index)
             if (jet_index(i) /= jet) cycle PARTICLE
             associate (prt => pl1%prt(map(i)), n_src_prt => size(pl1%prt(map(i))%src))
               do k = 1, n_src_prt
                  src_fill(n_src_fill + k) = prt%src(k)
               end do
               n_src_fill = n_src_fill + n_src_prt
               if (is_quark (prt%pdg)) then
                  n_quarks = n_quarks + 1
                  if (combined_pdg == 0) combined_pdg = prt%pdg
               end if
             end associate
          end do PARTICLE
          if (keep_jets .and. n_quarks == 1) pdg = combined_pdg
          call prt_init_pseudojet (subevt%prt(jet), jet_out(jet), src_fill(:n_src_fill), pdg)
       end do
     end subroutine fill_pseudojet
   end subroutine subevt_cluster
 
 @ %def subevt_cluster
 @ Return a list of all particles for which the mask is true.
 <<Subevents: public>>=
   public :: subevt_select
 <<Subevents: procedures>>=
   subroutine subevt_select (subevt, pl, mask1)
     type(subevt_t), intent(inout) :: subevt
     type(subevt_t), intent(in) :: pl
     logical, dimension(:), intent(in) :: mask1
     integer :: i, n
     call subevt_reset (subevt, pl%n_active)
     n = 0
     do i = 1, pl%n_active
        if (mask1(i)) then
           n = n + 1
           subevt%prt(n) = pl%prt(i)
        end if
     end do
     subevt%n_active = n
   end subroutine subevt_select
 
 @ %def subevt_select
 @ Return a subevent which consists of the single particle with
 specified [[index]].  If [[index]] is negative, count from the end.
 If it is out of bounds, return an empty list.
 <<Subevents: public>>=
   public :: subevt_extract
 <<Subevents: procedures>>=
   subroutine subevt_extract (subevt, pl, index)
     type(subevt_t), intent(inout) :: subevt
     type(subevt_t), intent(in) :: pl
     integer, intent(in) :: index
     if (index > 0) then
        if (index <= pl%n_active) then
           call subevt_reset (subevt, 1)
           subevt%prt(1) = pl%prt(index)
        else
           call subevt_reset (subevt, 0)
        end if
     else if (index < 0) then
        if (abs (index) <= pl%n_active) then
           call subevt_reset (subevt, 1)
           subevt%prt(1) = pl%prt(pl%n_active + 1 + index)
        else
           call subevt_reset (subevt, 0)
        end if
     else
        call subevt_reset (subevt, 0)
     end if
   end subroutine subevt_extract
 
 @ %def subevt_extract
 @ Return the list of particles sorted according to increasing values
 of the provided integer or real array.  If no array is given, sort by
 PDG value.
 <<Subevents: public>>=
   public :: subevt_sort
 <<Subevents: interfaces>>=
   interface subevt_sort
      module procedure subevt_sort_pdg
      module procedure subevt_sort_int
      module procedure subevt_sort_real
   end interface
 
 <<Subevents: procedures>>=
   subroutine subevt_sort_pdg (subevt, pl)
     type(subevt_t), intent(inout) :: subevt
     type(subevt_t), intent(in) :: pl
     integer :: n
     n = subevt%n_active
     call subevt_sort_int (subevt, pl, abs (3 * subevt%prt(:n)%pdg - 1))
   end subroutine subevt_sort_pdg
 
   subroutine subevt_sort_int (subevt, pl, ival)
     type(subevt_t), intent(inout) :: subevt
     type(subevt_t), intent(in) :: pl
     integer, dimension(:), intent(in) :: ival
     call subevt_reset (subevt, pl%n_active)
     subevt%n_active = pl%n_active
     subevt%prt = pl%prt( order (ival) )
   end subroutine subevt_sort_int
 
   subroutine subevt_sort_real (subevt, pl, rval)
     type(subevt_t), intent(inout) :: subevt
     type(subevt_t), intent(in) :: pl
     real(default), dimension(:), intent(in) :: rval
     integer :: i
     integer, dimension(size(rval)) :: idx
     call subevt_reset (subevt, pl%n_active)
     subevt%n_active = pl%n_active
     if (allocated (subevt%prt))  deallocate (subevt%prt)
     allocate (subevt%prt (size(pl%prt)))
     idx = order (rval)
     do i = 1, size (idx)
        subevt%prt(i) = pl%prt (idx(i))
     end do
   end subroutine subevt_sort_real
 
 @ %def subevt_sort
 @ Return the list of particles which have any of the specified PDG
 codes (and optionally particle type: beam, incoming, outgoing).
 
 The [[pack]] command was buggy in some gfortran versions, therefore it
 is unrolled.  The unrolled version may be more efficient, actually.
 <<Subevents: public>>=
   public :: subevt_select_pdg_code
 <<Subevents: procedures>>=
   subroutine subevt_select_pdg_code (subevt, aval, subevt_in, prt_type)
     type(subevt_t), intent(inout) :: subevt
     type(pdg_array_t), intent(in) :: aval
     type(subevt_t), intent(in) :: subevt_in
     integer, intent(in), optional :: prt_type
     integer :: n_active, n_match
     logical, dimension(:), allocatable :: mask
     integer :: i, j
     n_active = subevt_in%n_active
     allocate (mask (n_active))
     forall (i = 1:n_active) &
          mask(i) = aval .match. subevt_in%prt(i)%pdg
     if (present (prt_type)) &
          mask = mask .and. subevt_in%prt(:n_active)%type == prt_type
     n_match = count (mask)
     call subevt_reset (subevt, n_match)
     !!! !!! !!! Workaround for gfortran compiler bug
     ! subevt%prt(:n_match) = pack (subevt_in%prt(:n_active), mask)
     j = 0
     do i = 1, n_active
        if (mask(i)) then
           j = j + 1
           subevt%prt(j) = subevt_in%prt(i)
        end if
     end do
   end subroutine subevt_select_pdg_code
 
 @ %def subevt_select_pdg_code
 @
 \subsection{Eliminate numerical noise}
 This is useful for testing purposes: set entries to zero that are smaller in
 absolute values than a given tolerance parameter.
 
 Note: instead of setting the tolerance in terms of EPSILON
 (kind-dependent), we fix it to $10^{-16}$, which is the typical value
 for double precision.  The reason is that there are situations where
 intermediate representations (external libraries, files) are limited
 to double precision, even if the main program uses higher precision.
 <<Subevents: public>>=
   public :: pacify
 <<Subevents: interfaces>>=
   interface pacify
      module procedure pacify_prt
      module procedure pacify_subevt
   end interface pacify
 
 @ %def pacify
 <<Subevents: procedures>>=
   subroutine pacify_prt (prt)
     class(prt_t), intent(inout) :: prt
     real(default) :: e
     e = max (1E-10_default * energy (prt%p), 1E-13_default)
     call pacify (prt%p, e)
     call pacify (prt%p2, 1E3_default * e)
   end subroutine pacify_prt
 
   subroutine pacify_subevt (subevt)
     class(subevt_t), intent(inout) :: subevt
     integer :: i
     do i = 1, subevt%n_active
        call pacify (subevt%prt(i))
     end do
   end subroutine pacify_subevt
 
 @ %def pacify_prt
 @ %def pacify_subevt
 @
 \clearpage
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{Analysis tools}
 
 This module defines structures useful for data analysis.  These
 include observables, histograms, and plots.
 
 Observables are quantities that are calculated and summed up event by
 event.  At the end, one can compute the average and error.
 
 Histograms have their bins in addition to the observable properties.
 Histograms are usually written out in tables and displayed
 graphically.
 
 In plots, each record creates its own entry in a table.  This can be
 used for scatter plots if called event by event, or for plotting
 dependencies on parameters if called once per integration run.
 
 Graphs are container for histograms and plots, which carry their own graphics
 options.
 
 The type layout is still somewhat obfuscated.  This would become much simpler
 if type extension could be used.
 <<[[analysis.f90]]>>=
 <<File header>>
 
 module analysis
 
 <<Use kinds>>
 <<Use strings>>
   use io_units
   use format_utils, only: quote_underscore, tex_format
   use system_defs, only: TAB
   use diagnostics
   use os_interface
   use ifiles
 
 <<Standard module head>>
 
 <<Analysis: public>>
 
 <<Analysis: parameters>>
 
 <<Analysis: types>>
 
 <<Analysis: interfaces>>
 
 <<Analysis: variables>>
 
 contains
 
 <<Analysis: procedures>>
 
 end module analysis
 @ %def analysis
 @
 \subsection{Output formats}
 These formats share a common field width (alignment).
 <<Analysis: parameters>>=
   character(*), parameter, public :: HISTOGRAM_HEAD_FORMAT = "1x,A15,3x"
   character(*), parameter, public :: HISTOGRAM_INTG_FORMAT = "3x,I9,3x"
   character(*), parameter, public :: HISTOGRAM_DATA_FORMAT = "ES19.12"
 
 @ %def HISTOGRAM_HEAD_FORMAT HISTOGRAM_INTG_FORMAT HISTOGRAM_DATA_FORMAT
 @
 \subsection{Graph options}
 These parameters are used for displaying data.  They apply to a whole graph,
 which may contain more than one plot element.
 
 The GAMELAN code chunks are part of both [[graph_options]] and
 [[drawing_options]].  The [[drawing_options]] copy is used in histograms and
 plots, also as graph elements.  The [[graph_options]] copy is used for
 [[graph]] objects as a whole.  Both copies are usually identical.
 <<Analysis: public>>=
   public :: graph_options_t
 <<Analysis: types>>=
   type :: graph_options_t
      private
      type(string_t) :: id
      type(string_t) :: title
      type(string_t) :: description
      type(string_t) :: x_label
      type(string_t) :: y_label
      integer :: width_mm = 130
      integer :: height_mm = 90
      logical :: x_log = .false.
      logical :: y_log = .false.
      real(default) :: x_min = 0
      real(default) :: x_max = 1
      real(default) :: y_min = 0
      real(default) :: y_max = 1
      logical :: x_min_set = .false.
      logical :: x_max_set = .false.
      logical :: y_min_set = .false.
      logical :: y_max_set = .false.
      type(string_t) :: gmlcode_bg
      type(string_t) :: gmlcode_fg
   end type graph_options_t
 
 @ %def graph_options_t
 @ Initialize the record, all strings are empty.  The limits are undefined.
 <<Analysis: public>>=
   public :: graph_options_init
 <<Analysis: procedures>>=
   subroutine graph_options_init (graph_options)
     type(graph_options_t), intent(out) :: graph_options
     graph_options%id = ""
     graph_options%title = ""
     graph_options%description = ""
     graph_options%x_label = ""
     graph_options%y_label = ""
     graph_options%gmlcode_bg = ""
     graph_options%gmlcode_fg = ""
   end subroutine graph_options_init
 
 @ %def graph_options_init
 @ Set individual options.
 <<Analysis: public>>=
   public :: graph_options_set
 <<Analysis: procedures>>=
   subroutine graph_options_set (graph_options, id, &
        title, description, x_label, y_label, width_mm, height_mm, &
        x_log, y_log, x_min, x_max, y_min, y_max, &
        gmlcode_bg, gmlcode_fg)
     type(graph_options_t), intent(inout) :: graph_options
     type(string_t), intent(in), optional :: id
     type(string_t), intent(in), optional :: title
     type(string_t), intent(in), optional :: description
     type(string_t), intent(in), optional :: x_label, y_label
     integer, intent(in), optional :: width_mm, height_mm
     logical, intent(in), optional :: x_log, y_log
     real(default), intent(in), optional :: x_min, x_max, y_min, y_max
     type(string_t), intent(in), optional :: gmlcode_bg, gmlcode_fg
     if (present (id))  graph_options%id = id
     if (present (title))  graph_options%title = title
     if (present (description))  graph_options%description = description
     if (present (x_label))  graph_options%x_label = x_label
     if (present (y_label))  graph_options%y_label = y_label
     if (present (width_mm))   graph_options%width_mm  = width_mm
     if (present (height_mm))  graph_options%height_mm = height_mm
     if (present (x_log))  graph_options%x_log = x_log
     if (present (y_log))  graph_options%y_log = y_log
     if (present (x_min))  graph_options%x_min = x_min
     if (present (x_max))  graph_options%x_max = x_max
     if (present (y_min))  graph_options%y_min = y_min
     if (present (y_max))  graph_options%y_max = y_max
     if (present (x_min))  graph_options%x_min_set = .true.
     if (present (x_max))  graph_options%x_max_set = .true.
     if (present (y_min))  graph_options%y_min_set = .true.
     if (present (y_max))  graph_options%y_max_set = .true.
     if (present (gmlcode_bg))  graph_options%gmlcode_bg = gmlcode_bg
     if (present (gmlcode_fg))  graph_options%gmlcode_fg = gmlcode_fg
   end subroutine graph_options_set
 
 @ %def graph_options_set
 @ Write a simple account of all options.
 <<Analysis: public>>=
   public :: graph_options_write
 <<Analysis: procedures>>=
   subroutine graph_options_write (gro, unit)
     type(graph_options_t), intent(in) :: gro
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
 1   format (A,1x,'"',A,'"')
 2   format (A,1x,L1)
 3   format (A,1x,ES19.12)
 4   format (A,1x,I0)
 5   format (A,1x,'[undefined]')
     write (u, 1)  "title       =", char (gro%title)
     write (u, 1)  "description =", char (gro%description)
     write (u, 1)  "x_label     =", char (gro%x_label)
     write (u, 1)  "y_label     =", char (gro%y_label)
     write (u, 2)  "x_log       =", gro%x_log
     write (u, 2)  "y_log       =", gro%y_log
     if (gro%x_min_set) then
        write (u, 3)  "x_min       =", gro%x_min
     else
        write (u, 5)  "x_min       ="
     end if
     if (gro%x_max_set) then
        write (u, 3)  "x_max       =", gro%x_max
     else
        write (u, 5)  "x_max       ="
     end if
     if (gro%y_min_set) then
        write (u, 3)  "y_min       =", gro%y_min
     else
        write (u, 5)  "y_min       ="
     end if
     if (gro%y_max_set) then
        write (u, 3)  "y_max       =", gro%y_max
     else
        write (u, 5)  "y_max       ="
     end if
     write (u, 4)  "width_mm    =", gro%width_mm
     write (u, 4)  "height_mm   =", gro%height_mm
     write (u, 1)  "gmlcode_bg  =", char (gro%gmlcode_bg)
     write (u, 1)  "gmlcode_fg  =", char (gro%gmlcode_fg)
   end subroutine graph_options_write
 
 @ %def graph_options_write
 @ Write a \LaTeX\ header/footer for the analysis file.
 <<Analysis: procedures>>=
   subroutine graph_options_write_tex_header (gro, unit)
     type(graph_options_t), intent(in) :: gro
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
     if (gro%title /= "") then
        write (u, "(A)")
        write (u, "(A)")  "\section{" // char (gro%title) // "}"
     else
        write (u, "(A)")  "\section{" // char (quote_underscore (gro%id)) // "}"
     end if
     if (gro%description /= "") then
        write (u, "(A)")  char (gro%description)
        write (u, *)
        write (u, "(A)")  "\vspace*{\baselineskip}"
     end if
     write (u, "(A)")  "\vspace*{\baselineskip}"
     write (u, "(A)")  "\unitlength 1mm"
     write (u, "(A,I0,',',I0,A)")  &
          "\begin{gmlgraph*}(", &
          gro%width_mm, gro%height_mm, &
          ")[dat]"
   end subroutine graph_options_write_tex_header
 
   subroutine graph_options_write_tex_footer (gro, unit)
     type(graph_options_t), intent(in) :: gro
     integer, intent(in), optional :: unit
     integer :: u, width, height
     width = gro%width_mm - 10
     height = gro%height_mm - 10
     u = given_output_unit (unit)
     write (u, "(A)")  "  begingmleps ""Whizard-Logo.eps"";"
     write (u, "(A,I0,A,I0,A)")  &
          "    base := (", width, "*unitlength,", height, "*unitlength);"
     write (u, "(A)")  "    height := 9.6*unitlength;"
     write (u, "(A)")  "    width := 11.2*unitlength;"
     write (u, "(A)")  "  endgmleps;"
     write (u, "(A)")  "\end{gmlgraph*}"
   end subroutine graph_options_write_tex_footer
 
 @ %def graph_options_write_tex_header
 @ %def graph_options_write_tex_footer
 @ Return the analysis object ID.
 <<Analysis: procedures>>=
   function graph_options_get_id (gro) result (id)
     type(string_t) :: id
     type(graph_options_t), intent(in) :: gro
     id = gro%id
   end function graph_options_get_id
 
 @ %def graph_options_get_id
 @ Create an appropriate [[setup]] command (linear/log).
 <<Analysis: procedures>>=
   function graph_options_get_gml_setup (gro) result (cmd)
     type(string_t) :: cmd
     type(graph_options_t), intent(in) :: gro
     type(string_t) :: x_str, y_str
     if (gro%x_log) then
        x_str = "log"
     else
        x_str = "linear"
     end if
     if (gro%y_log) then
        y_str = "log"
     else
        y_str = "linear"
     end if
     cmd = "setup (" // x_str // ", " // y_str // ");"
   end function graph_options_get_gml_setup
 
 @ %def graph_options_get_gml_setup
 @ Return the labels in GAMELAN form.
 <<Analysis: procedures>>=
   function graph_options_get_gml_x_label (gro) result (cmd)
     type(string_t) :: cmd
     type(graph_options_t), intent(in) :: gro
     cmd = 'label.bot (<' // '<' // gro%x_label // '>' // '>, out);'
   end function graph_options_get_gml_x_label
 
   function graph_options_get_gml_y_label (gro) result (cmd)
     type(string_t) :: cmd
     type(graph_options_t), intent(in) :: gro
     cmd = 'label.ulft (<' // '<' // gro%y_label // '>' // '>, out);'
   end function graph_options_get_gml_y_label
 
 @ %def graph_options_get_gml_x_label
 @ %def graph_options_get_gml_y_label
 @ Create an appropriate [[graphrange]] statement for the given graph options.
 Where the graph options are not set, use the supplied arguments, if any,
 otherwise set the undefined value.
 <<Analysis: procedures>>=
   function graph_options_get_gml_graphrange &
        (gro, x_min, x_max, y_min, y_max) result (cmd)
     type(string_t) :: cmd
     type(graph_options_t), intent(in) :: gro
     real(default), intent(in), optional :: x_min, x_max, y_min, y_max
     type(string_t) :: x_min_str, x_max_str, y_min_str, y_max_str
     character(*), parameter :: fmt = "(ES15.8)"
     if (gro%x_min_set) then
        x_min_str = "#" // trim (adjustl (real2string (gro%x_min, fmt)))
     else if (present (x_min)) then
        x_min_str = "#" // trim (adjustl (real2string (x_min, fmt)))
     else
        x_min_str = "??"
     end if
     if (gro%x_max_set) then
        x_max_str = "#" // trim (adjustl (real2string (gro%x_max, fmt)))
     else if (present (x_max)) then
        x_max_str = "#" // trim (adjustl (real2string (x_max, fmt)))
     else
        x_max_str = "??"
     end if
     if (gro%y_min_set) then
        y_min_str = "#" // trim (adjustl (real2string (gro%y_min, fmt)))
     else if (present (y_min)) then
        y_min_str = "#" // trim (adjustl (real2string (y_min, fmt)))
     else
        y_min_str = "??"
     end if
     if (gro%y_max_set) then
        y_max_str = "#" // trim (adjustl (real2string (gro%y_max, fmt)))
     else if (present (y_max)) then
        y_max_str = "#" // trim (adjustl (real2string (y_max, fmt)))
     else
        y_max_str = "??"
     end if
     cmd = "graphrange (" // x_min_str // ", " // y_min_str // "), " &
          // "(" // x_max_str // ", " // y_max_str // ");"
   end function graph_options_get_gml_graphrange
 
 @ %def graph_options_get_gml_graphrange
 @ Get extra GAMELAN code to be executed before and after the usual drawing
 commands.
 <<Analysis: procedures>>=
   function graph_options_get_gml_bg_command (gro) result (cmd)
     type(string_t) :: cmd
     type(graph_options_t), intent(in) :: gro
     cmd = gro%gmlcode_bg
   end function graph_options_get_gml_bg_command
 
   function graph_options_get_gml_fg_command (gro) result (cmd)
     type(string_t) :: cmd
     type(graph_options_t), intent(in) :: gro
     cmd = gro%gmlcode_fg
   end function graph_options_get_gml_fg_command
 
 @ %def graph_options_get_gml_bg_command
 @ %def graph_options_get_gml_fg_command
 @ Append the header for generic data output in ifile format.  We print only
 labels, not graphics parameters.
 <<Analysis: procedures>>=
   subroutine graph_options_get_header (pl, header, comment)
     type(graph_options_t), intent(in) :: pl
     type(ifile_t), intent(inout) :: header
     type(string_t), intent(in), optional :: comment
     type(string_t) :: c
     if (present (comment)) then
        c = comment
     else
        c = ""
     end if
     call ifile_append (header, &
          c // "ID: " // pl%id)
     call ifile_append (header, &
          c // "title: " // pl%title)
     call ifile_append (header, &
          c // "description: " // pl%description)
     call ifile_append (header, &
          c // "x axis label: " // pl%x_label)
     call ifile_append (header, &
          c // "y axis label: " // pl%y_label)
   end subroutine graph_options_get_header
 
 @ %def graph_options_get_header
 @
 \subsection{Drawing options}
 These options apply to an individual graph element (histogram or plot).
 <<Analysis: public>>=
   public :: drawing_options_t
 <<Analysis: types>>=
   type :: drawing_options_t
      type(string_t) :: dataset
      logical :: with_hbars = .false.
      logical :: with_base = .false.
      logical :: piecewise = .false.
      logical :: fill = .false.
      logical :: draw = .false.
      logical :: err = .false.
      logical :: symbols = .false.
      type(string_t) :: fill_options
      type(string_t) :: draw_options
      type(string_t) :: err_options
      type(string_t) :: symbol
      type(string_t) :: gmlcode_bg
      type(string_t) :: gmlcode_fg
   end type drawing_options_t
 
 @ %def drawing_options_t
 @ Write a simple account of all options.
 <<Analysis: public>>=
   public :: drawing_options_write
 <<Analysis: procedures>>=
   subroutine drawing_options_write (dro, unit)
      type(drawing_options_t), intent(in) :: dro
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit)
 1   format (A,1x,'"',A,'"')
 2   format (A,1x,L1)
     write (u, 2)  "with_hbars  =", dro%with_hbars
     write (u, 2)  "with_base   =", dro%with_base
     write (u, 2)  "piecewise   =", dro%piecewise
     write (u, 2)  "fill        =", dro%fill
     write (u, 2)  "draw        =", dro%draw
     write (u, 2)  "err         =", dro%err
     write (u, 2)  "symbols     =", dro%symbols
     write (u, 1)  "fill_options=", char (dro%fill_options)
     write (u, 1)  "draw_options=", char (dro%draw_options)
     write (u, 1)  "err_options =", char (dro%err_options)
     write (u, 1)  "symbol      =", char (dro%symbol)
     write (u, 1)  "gmlcode_bg  =", char (dro%gmlcode_bg)
     write (u, 1)  "gmlcode_fg  =", char (dro%gmlcode_fg)
   end subroutine drawing_options_write
 
 @ %def drawing_options_write
 @ Init with empty strings and default options, appropriate for either
 histogram or plot.
 <<Analysis: public>>=
   public :: drawing_options_init_histogram
   public :: drawing_options_init_plot
 <<Analysis: procedures>>=
   subroutine drawing_options_init_histogram (dro)
     type(drawing_options_t), intent(out) :: dro
     dro%dataset = "dat"
     dro%with_hbars = .true.
     dro%with_base = .true.
     dro%piecewise = .true.
     dro%fill = .true.
     dro%draw = .true.
     dro%fill_options = "withcolor col.default"
     dro%draw_options = ""
     dro%err_options = ""
     dro%symbol = "fshape(circle scaled 1mm)()"
     dro%gmlcode_bg = ""
     dro%gmlcode_fg = ""
   end subroutine drawing_options_init_histogram
 
   subroutine drawing_options_init_plot (dro)
     type(drawing_options_t), intent(out) :: dro
     dro%dataset = "dat"
     dro%draw = .true.
     dro%fill_options = "withcolor col.default"
     dro%draw_options = ""
     dro%err_options = ""
     dro%symbol = "fshape(circle scaled 1mm)()"
     dro%gmlcode_bg = ""
     dro%gmlcode_fg = ""
   end subroutine drawing_options_init_plot
 
 @ %def drawing_options_init_histogram
 @ %def drawing_options_init_plot
 @ Set individual options.
 <<Analysis: public>>=
   public :: drawing_options_set
 <<Analysis: procedures>>=
   subroutine drawing_options_set (dro, dataset, &
        with_hbars, with_base, piecewise, fill, draw, err, symbols, &
        fill_options, draw_options, err_options, symbol, &
        gmlcode_bg, gmlcode_fg)
     type(drawing_options_t), intent(inout) :: dro
     type(string_t), intent(in), optional :: dataset
     logical, intent(in), optional :: with_hbars, with_base, piecewise
     logical, intent(in), optional :: fill, draw, err, symbols
     type(string_t), intent(in), optional :: fill_options, draw_options
     type(string_t), intent(in), optional :: err_options, symbol
     type(string_t), intent(in), optional :: gmlcode_bg, gmlcode_fg
     if (present (dataset))  dro%dataset = dataset
     if (present (with_hbars))  dro%with_hbars = with_hbars
     if (present (with_base))  dro%with_base = with_base
     if (present (piecewise))  dro%piecewise = piecewise
     if (present (fill))  dro%fill = fill
     if (present (draw))  dro%draw = draw
     if (present (err))  dro%err = err
     if (present (symbols))  dro%symbols = symbols
     if (present (fill_options))  dro%fill_options = fill_options
     if (present (draw_options))  dro%draw_options = draw_options
     if (present (err_options))  dro%err_options = err_options
     if (present (symbol))  dro%symbol = symbol
     if (present (gmlcode_bg))  dro%gmlcode_bg = gmlcode_bg
     if (present (gmlcode_fg))  dro%gmlcode_fg = gmlcode_fg
   end subroutine drawing_options_set
 
 @ %def drawing_options_set
 @ There are sepate commands for drawing the
 curve and for drawing errors.  The symbols are applied to the latter.  First
 of all, we may have to compute a baseline:
 <<Analysis: procedures>>=
   function drawing_options_get_calc_command (dro) result (cmd)
     type(string_t) :: cmd
     type(drawing_options_t), intent(in) :: dro
     if (dro%with_base) then
        cmd = "calculate " // dro%dataset // ".base (" // dro%dataset // ") " &
             // "(x, #0);"
     else
        cmd = ""
     end if
   end function drawing_options_get_calc_command
 
 @ %def drawing_options_get_calc_command
 @ Return the drawing command.
 <<Analysis: procedures>>=
   function drawing_options_get_draw_command (dro) result (cmd)
     type(string_t) :: cmd
     type(drawing_options_t), intent(in) :: dro
     if (dro%fill) then
        cmd = "fill"
     else if (dro%draw) then
        cmd = "draw"
     else
        cmd = ""
     end if
     if (dro%fill .or. dro%draw) then
        if (dro%piecewise)  cmd = cmd // " piecewise"
        if (dro%draw .and. dro%with_base)  cmd = cmd // " cyclic"
        cmd = cmd // " from (" // dro%dataset
        if (dro%with_base) then
           if (dro%piecewise) then
              cmd = cmd // ", " // dro%dataset // ".base/\"  ! "
           else
              cmd = cmd // " ~ " // dro%dataset // ".base\"  ! "
           end if
        end if
        cmd = cmd // ")"
        if (dro%fill) then
           cmd = cmd // " " // dro%fill_options
           if (dro%draw)  cmd = cmd // " outlined"
        end if
        if (dro%draw)  cmd = cmd // " " // dro%draw_options
        cmd = cmd // ";"
     end if
   end function drawing_options_get_draw_command
 
 @ %def drawing_options_get_draw_command
 @ The error command draws error bars, if any.
 <<Analysis: procedures>>=
   function drawing_options_get_err_command (dro) result (cmd)
     type(string_t) :: cmd
     type(drawing_options_t), intent(in) :: dro
     if (dro%err) then
        cmd = "draw piecewise " &
             // "from (" // dro%dataset // ".err)" &
             // " " // dro%err_options // ";"
     else
        cmd = ""
     end if
   end function drawing_options_get_err_command
 
 @ %def drawing_options_get_err_command
 @ The symbol command draws symbols, if any.
 <<Analysis: procedures>>=
   function drawing_options_get_symb_command (dro) result (cmd)
     type(string_t) :: cmd
     type(drawing_options_t), intent(in) :: dro
     if (dro%symbols) then
        cmd = "phantom" &
             // " from (" // dro%dataset // ")" &
             // " withsymbol (" // dro%symbol // ");"
     else
        cmd = ""
     end if
   end function drawing_options_get_symb_command
 
 @ %def drawing_options_get_symb_command
 @ Get extra GAMELAN code to be executed before and after the usual drawing
 commands.
 <<Analysis: procedures>>=
   function drawing_options_get_gml_bg_command (dro) result (cmd)
     type(string_t) :: cmd
     type(drawing_options_t), intent(in) :: dro
     cmd = dro%gmlcode_bg
   end function drawing_options_get_gml_bg_command
 
   function drawing_options_get_gml_fg_command (dro) result (cmd)
     type(string_t) :: cmd
     type(drawing_options_t), intent(in) :: dro
     cmd = dro%gmlcode_fg
   end function drawing_options_get_gml_fg_command
 
 @ %def drawing_options_get_gml_bg_command
 @ %def drawing_options_get_gml_fg_command
 @
 \subsection{Observables}
 The observable type holds the accumulated observable values and weight
 sums which are necessary for proper averaging.
 <<Analysis: types>>=
   type :: observable_t
      private
      real(default) :: sum_values = 0
      real(default) :: sum_squared_values = 0
      real(default) :: sum_weights = 0
      real(default) :: sum_squared_weights = 0
      integer :: count = 0
      type(string_t) :: obs_label
      type(string_t) :: obs_unit
      type(graph_options_t) :: graph_options
   end type observable_t
 
 @ %def observable_t
 @ Initialize with defined properties
 <<Analysis: procedures>>=
   subroutine observable_init (obs, obs_label, obs_unit, graph_options)
     type(observable_t), intent(out) :: obs
     type(string_t), intent(in), optional :: obs_label, obs_unit
     type(graph_options_t), intent(in), optional :: graph_options
     if (present (obs_label)) then
        obs%obs_label = obs_label
     else
        obs%obs_label = ""
     end if
     if (present (obs_unit)) then
        obs%obs_unit = obs_unit
     else
        obs%obs_unit = ""
     end if
     if (present (graph_options)) then
        obs%graph_options = graph_options
     else
        call graph_options_init (obs%graph_options)
     end if
   end subroutine observable_init
 
 @ %def observable_init
 @ Reset all numeric entries.
 <<Analysis: procedures>>=
   subroutine observable_clear (obs)
     type(observable_t), intent(inout) :: obs
     obs%sum_values = 0
     obs%sum_squared_values = 0
     obs%sum_weights = 0
     obs%sum_squared_weights = 0
     obs%count = 0
   end subroutine observable_clear
 
 @ %def observable_clear
 @ Record a a value.  Always successful for observables.
 <<Analysis: interfaces>>=
   interface observable_record_value
      module procedure observable_record_value_unweighted
      module procedure observable_record_value_weighted
   end interface
 
 <<Analysis: procedures>>=
   subroutine observable_record_value_unweighted (obs, value, success)
     type(observable_t), intent(inout) :: obs
     real(default), intent(in) :: value
     logical, intent(out), optional :: success
     obs%sum_values = obs%sum_values + value
     obs%sum_squared_values = obs%sum_squared_values + value**2
     obs%sum_weights = obs%sum_weights + 1
     obs%sum_squared_weights = obs%sum_squared_weights + 1
     obs%count = obs%count + 1
     if (present (success))  success = .true.
   end subroutine observable_record_value_unweighted
 
   subroutine observable_record_value_weighted (obs, value, weight, success)
     type(observable_t), intent(inout) :: obs
     real(default), intent(in) :: value, weight
     logical, intent(out), optional :: success
     obs%sum_values = obs%sum_values + value * weight
     obs%sum_squared_values = obs%sum_squared_values + value**2 * weight
     obs%sum_weights = obs%sum_weights + abs (weight)
     obs%sum_squared_weights = obs%sum_squared_weights + weight**2
     obs%count = obs%count + 1
     if (present (success))  success = .true.
   end subroutine observable_record_value_weighted
 
 @ %def observable_record_value
 @ Here are the statistics formulas:
 \begin{enumerate}
 \item Unweighted case:
   Given a sample of $n$ values $x_i$, the average is
   \begin{equation}
     \langle x \rangle = \frac{\sum x_i}{n}
   \end{equation}
   and the error estimate
   \begin{align}
     \Delta x &= \sqrt{\frac{1}{n-1}\langle{\sum(x_i - \langle x\rangle)^2}}
     \\
     &= \sqrt{\frac{1}{n-1}
              \left(\frac{\sum x_i^2}{n} - \frac{(\sum x_i)^2}{n^2}\right)}
   \end{align}
 \item Weighted case:
   Instead of weight 1, each event comes with weight $w_i$.
   \begin{equation}
     \langle x \rangle = \frac{\sum x_i w_i}{\sum w_i}
   \end{equation}
   and
   \begin{equation}
     \Delta x
     = \sqrt{\frac{1}{n-1}
             \left(\frac{\sum x_i^2 w_i}{\sum w_i}
                   - \frac{(\sum x_i w_i)^2}{(\sum w_i)^2}\right)}
   \end{equation}
   For $w_i=1$, this specializes to the previous formula.
 \end{enumerate}
 <<Analysis: procedures>>=
   function observable_get_n_entries (obs) result (n)
     integer :: n
     type(observable_t), intent(in) :: obs
     n = obs%count
   end function observable_get_n_entries
 
   function observable_get_average (obs) result (avg)
     real(default) :: avg
     type(observable_t), intent(in) :: obs
     if (obs%sum_weights /= 0) then
        avg = obs%sum_values / obs%sum_weights
     else
        avg = 0
     end if
   end function observable_get_average
 
   function observable_get_error (obs) result (err)
     real(default) :: err
     type(observable_t), intent(in) :: obs
     real(default) :: var, n
     if (obs%sum_weights /= 0) then
        select case (obs%count)
        case (0:1)
           err = 0
        case default
           n = obs%count
           var = obs%sum_squared_values / obs%sum_weights &
                 - (obs%sum_values / obs%sum_weights) ** 2
           err = sqrt (max (var, 0._default) / (n - 1))
        end select
     else
        err = 0
     end if
   end function observable_get_error
 
 @ %def observable_get_n_entries
 @ %def observable_get_sum
 @ %def observable_get_average
 @ %def observable_get_error
 @ Write label and/or physical unit to a string.
 <<Analysis: procedures>>=
   function observable_get_label (obs, wl, wu) result (string)
     type(string_t) :: string
     type(observable_t), intent(in) :: obs
     logical, intent(in) :: wl, wu
     type(string_t) :: obs_label, obs_unit
     if (wl) then
        if (obs%obs_label /= "") then
           obs_label = obs%obs_label
        else
           obs_label = "\textrm{Observable}"
        end if
     else
        obs_label = ""
     end if
     if (wu) then
        if (obs%obs_unit /= "") then
           if (wl) then
              obs_unit = "\;[" // obs%obs_unit // "]"
           else
              obs_unit = obs%obs_unit
           end if
        else
           obs_unit = ""
        end if
     else
        obs_unit = ""
     end if
     string = obs_label // obs_unit
   end function observable_get_label
 
 @ %def observable_get_label
 @
 \subsection{Output}
 <<Analysis: procedures>>=
   subroutine observable_write (obs, unit)
     type(observable_t), intent(in) :: obs
     integer, intent(in), optional :: unit
     real(default) :: avg, err, relerr
     integer :: n
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     avg = observable_get_average (obs)
     err = observable_get_error (obs)
     if (avg /= 0) then
        relerr = err / abs (avg)
     else
        relerr = 0
     end if
     n = observable_get_n_entries (obs)
     if (obs%graph_options%title /= "") then
        write (u, "(A,1x,3A)") &
             "title       =", '"', char (obs%graph_options%title), '"'
     end if
     if (obs%graph_options%title /= "") then
        write (u, "(A,1x,3A)") &
             "description =", '"', char (obs%graph_options%description), '"'
     end if
     write (u, "(A,1x," // HISTOGRAM_DATA_FORMAT // ")", advance = "no") &
          "average     =", avg
     call write_unit ()
     write (u, "(A,1x," // HISTOGRAM_DATA_FORMAT // ")", advance = "no") &
          "error[abs]  =", err
     call write_unit ()
     write (u, "(A,1x," // HISTOGRAM_DATA_FORMAT // ")") &
          "error[rel]  =", relerr
     write (u, "(A,1x,I0)") &
          "n_entries   =", n
   contains
     subroutine write_unit ()
       if (obs%obs_unit /= "") then
          write (u, "(1x,A)")  char (obs%obs_unit)
       else
          write (u, *)
       end if
     end subroutine write_unit
   end subroutine observable_write
 
 @ %def observable_write
 @ \LaTeX\ output.
 <<Analysis: procedures>>=
   subroutine observable_write_driver (obs, unit, write_heading)
     type(observable_t), intent(in) :: obs
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: write_heading
     real(default) :: avg, err
     integer :: n_digits
     logical :: heading
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     heading = .true.;  if (present (write_heading))  heading = write_heading
     avg = observable_get_average (obs)
     err = observable_get_error (obs)
     if (avg /= 0 .and. err /= 0) then
        n_digits = max (2, 2 - int (log10 (abs (err / real (avg, default)))))
     else if (avg /= 0) then
        n_digits = 100
     else
        n_digits = 1
     end if
     if (heading) then
        write (u, "(A)")
        if (obs%graph_options%title /= "") then
           write (u, "(A)")  "\section{" // char (obs%graph_options%title) &
                // "}"
        else
           write (u, "(A)")  "\section{Observable}"
        end if
        if (obs%graph_options%description /= "") then
           write (u, "(A)")  char (obs%graph_options%description)
           write (u, *)
        end if
        write (u, "(A)")  "\begin{flushleft}"
     end if
     write (u, "(A)", advance="no")  "  $\langle{" ! $ sign
     write (u, "(A)", advance="no")  char (observable_get_label (obs, wl=.true., wu=.false.))
     write (u, "(A)", advance="no")  "}\rangle = "
     write (u, "(A)", advance="no")  char (tex_format (avg, n_digits))
     write (u, "(A)", advance="no")  "\pm"
     write (u, "(A)", advance="no")  char (tex_format (err, 2))
     write (u, "(A)", advance="no")  "\;{"
     write (u, "(A)", advance="no")  char (observable_get_label (obs, wl=.false., wu=.true.))
     write (u, "(A)")  "}"
     write (u, "(A)", advance="no")  "     \quad[n_{\text{entries}} = "
     write (u, "(I0)",advance="no")  observable_get_n_entries (obs)
     write (u, "(A)")  "]$"          ! $ fool Emacs' noweb mode
     if (heading) then
        write (u, "(A)") "\end{flushleft}"
     end if
   end subroutine observable_write_driver
 
 @ %def observable_write_driver
 @
 \subsection{Histograms}
 \subsubsection{Bins}
 <<Analysis: types>>=
   type :: bin_t
      private
      real(default) :: midpoint = 0
      real(default) :: width = 0
      real(default) :: sum_weights = 0
      real(default) :: sum_squared_weights = 0
      real(default) :: sum_excess_weights = 0
      integer :: count = 0
   end type bin_t
 
 @ %def bin_t
 <<Analysis: procedures>>=
   subroutine bin_init (bin, midpoint, width)
     type(bin_t), intent(out) :: bin
     real(default), intent(in) :: midpoint, width
     bin%midpoint = midpoint
     bin%width = width
   end subroutine bin_init
 
 @ %def bin_init
 <<Analysis: procedures>>=
   elemental subroutine bin_clear (bin)
     type(bin_t), intent(inout) :: bin
     bin%sum_weights = 0
     bin%sum_squared_weights = 0
     bin%sum_excess_weights = 0
     bin%count = 0
   end subroutine bin_clear
 
 @ %def bin_clear
 <<Analysis: procedures>>=
   subroutine bin_record_value (bin, normalize, weight, excess)
     type(bin_t), intent(inout) :: bin
     logical, intent(in) :: normalize
     real(default), intent(in) :: weight
     real(default), intent(in), optional :: excess
     real(default) :: w, e
     if (normalize) then
        if (bin%width /= 0) then
           w = weight / bin%width
           if (present (excess))  e = excess / bin%width
        else
           w = 0
           if (present (excess))  e = 0
        end if
     else
        w = weight
        if (present (excess))  e = excess
     end if
     bin%sum_weights = bin%sum_weights + abs (w)
     bin%sum_squared_weights = bin%sum_squared_weights + w ** 2
     if (present (excess)) &
          bin%sum_excess_weights = bin%sum_excess_weights + abs (e)
     bin%count = bin%count + 1
   end subroutine bin_record_value
 
 @ %def bin_record_value
 <<Analysis: procedures>>=
   function bin_get_midpoint (bin) result (x)
     real(default) :: x
     type(bin_t), intent(in) :: bin
     x = bin%midpoint
   end function bin_get_midpoint
 
   function bin_get_width (bin) result (w)
     real(default) :: w
     type(bin_t), intent(in) :: bin
     w = bin%width
   end function bin_get_width
 
   function bin_get_n_entries (bin) result (n)
     integer :: n
     type(bin_t), intent(in) :: bin
     n = bin%count
   end function bin_get_n_entries
 
   function bin_get_sum (bin) result (s)
     real(default) :: s
     type(bin_t), intent(in) :: bin
     s = bin%sum_weights
   end function bin_get_sum
 
   function bin_get_error (bin) result (err)
     real(default) :: err
     type(bin_t), intent(in) :: bin
     err = sqrt (bin%sum_squared_weights)
   end function bin_get_error
 
   function bin_get_excess (bin) result (excess)
     real(default) :: excess
     type(bin_t), intent(in) :: bin
     excess = bin%sum_excess_weights
   end function bin_get_excess
 
 @ %def bin_get_midpoint
 @ %def bin_get_width
 @ %def bin_get_n_entries
 @ %def bin_get_sum
 @ %def bin_get_error
 @ %def bin_get_excess
 <<Analysis: procedures>>=
   subroutine bin_write_header (unit)
     integer, intent(in), optional :: unit
     character(120) :: buffer
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     write (buffer, "(A,4(1x," //HISTOGRAM_HEAD_FORMAT // "),2x,A)") &
          "#", "bin midpoint", "value    ", "error    ", &
          "excess     ", "n"
     write (u, "(A)")  trim (buffer)
   end subroutine bin_write_header
 
   subroutine bin_write (bin, unit)
     type(bin_t), intent(in) :: bin
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     write (u, "(1x,4(1x," // HISTOGRAM_DATA_FORMAT // "),2x,I0)") &
          bin_get_midpoint (bin), &
          bin_get_sum (bin), &
          bin_get_error (bin), &
          bin_get_excess (bin), &
          bin_get_n_entries (bin)
   end subroutine bin_write
 
 @ %def bin_write_header
 @ %def bin_write
 @
 \subsubsection{Histograms}
 <<Analysis: types>>=
   type :: histogram_t
      private
      real(default) :: lower_bound = 0
      real(default) :: upper_bound = 0
      real(default) :: width = 0
      integer :: n_bins = 0
      logical :: normalize_bins = .false.
      type(observable_t) :: obs
      type(observable_t) :: obs_within_bounds
      type(bin_t) :: underflow
      type(bin_t), dimension(:), allocatable :: bin
      type(bin_t) :: overflow
      type(graph_options_t) :: graph_options
      type(drawing_options_t) :: drawing_options
   end type histogram_t
 
 @ %def histogram_t
 @
 \subsubsection{Initializer/finalizer}
 Initialize a histogram.  We may provide either the bin width or the
 number of bins.  A finalizer is not needed, since the histogram contains no
 pointer (sub)components.
 <<Analysis: interfaces>>=
   interface histogram_init
      module procedure histogram_init_n_bins
      module procedure histogram_init_bin_width
   end interface
 
 <<Analysis: procedures>>=
   subroutine histogram_init_n_bins (h, id, &
        lower_bound, upper_bound, n_bins, normalize_bins, &
        obs_label, obs_unit, graph_options, drawing_options)
     type(histogram_t), intent(out) :: h
     type(string_t), intent(in) :: id
     real(default), intent(in) :: lower_bound, upper_bound
     integer, intent(in) :: n_bins
     logical, intent(in) :: normalize_bins
     type(string_t), intent(in), optional :: obs_label, obs_unit
     type(graph_options_t), intent(in), optional :: graph_options
     type(drawing_options_t), intent(in), optional :: drawing_options
     real(default) :: bin_width
     integer :: i
     call observable_init (h%obs_within_bounds, obs_label, obs_unit)
     call observable_init (h%obs, obs_label, obs_unit)
     h%lower_bound = lower_bound
     h%upper_bound = upper_bound
     h%n_bins = max (n_bins, 1)
     h%width = h%upper_bound - h%lower_bound
     h%normalize_bins = normalize_bins
     bin_width = h%width / h%n_bins
     allocate (h%bin (h%n_bins))
     call bin_init (h%underflow, h%lower_bound, 0._default)
     do i = 1, h%n_bins
        call bin_init (h%bin(i), &
             h%lower_bound - bin_width/2 + i * bin_width, bin_width)
     end do
     call bin_init (h%overflow, h%upper_bound, 0._default)
     if (present (graph_options)) then
        h%graph_options = graph_options
     else
        call graph_options_init (h%graph_options)
     end if
     call graph_options_set (h%graph_options, id = id)
     if (present (drawing_options)) then
        h%drawing_options = drawing_options
     else
        call drawing_options_init_histogram (h%drawing_options)
     end if
   end subroutine histogram_init_n_bins
 
   subroutine histogram_init_bin_width (h, id, &
        lower_bound, upper_bound, bin_width, normalize_bins, &
        obs_label, obs_unit, graph_options, drawing_options)
     type(histogram_t), intent(out) :: h
     type(string_t), intent(in) :: id
     real(default), intent(in) :: lower_bound, upper_bound, bin_width
     logical, intent(in) :: normalize_bins
     type(string_t), intent(in), optional :: obs_label, obs_unit
     type(graph_options_t), intent(in), optional :: graph_options
     type(drawing_options_t), intent(in), optional :: drawing_options
     integer :: n_bins
     if (bin_width /= 0) then
        n_bins = nint ((upper_bound - lower_bound) / bin_width)
     else
        n_bins = 1
     end if
     call histogram_init_n_bins (h, id, &
          lower_bound, upper_bound, n_bins, normalize_bins, &
          obs_label, obs_unit, graph_options, drawing_options)
   end subroutine histogram_init_bin_width
 
 @ %def histogram_init
 @ Initialize a histogram by copying another one.
 
 Since [[h]] has no pointer (sub)components, intrinsic assignment is
 sufficient.  Optionally, we replace the drawing options.
 <<Analysis: procedures>>=
   subroutine histogram_init_histogram (h, h_in, drawing_options)
     type(histogram_t), intent(out) :: h
     type(histogram_t), intent(in) :: h_in
     type(drawing_options_t), intent(in), optional :: drawing_options
     h = h_in
     if (present (drawing_options)) then
        h%drawing_options = drawing_options
     end if
   end subroutine histogram_init_histogram
 
 @ %def histogram_init_histogram
 @
 \subsubsection{Fill histograms}
 Clear the histogram contents, but do not modify the structure.
 <<Analysis: procedures>>=
   subroutine histogram_clear (h)
     type(histogram_t), intent(inout) :: h
     call observable_clear (h%obs)
     call observable_clear (h%obs_within_bounds)
     call bin_clear (h%underflow)
     if (allocated (h%bin))  call bin_clear (h%bin)
     call bin_clear (h%overflow)
   end subroutine histogram_clear
 
 @ %def histogram_clear
 @ Record a value.  Successful if the value is within bounds, otherwise
 it is recorded as under-/overflow.  Optionally, we may provide an
 excess weight that could be returned by the unweighting procedure.
 <<Analysis: procedures>>=
   subroutine histogram_record_value_unweighted (h, value, excess, success)
     type(histogram_t), intent(inout) :: h
     real(default), intent(in) :: value
     real(default), intent(in), optional :: excess
     logical, intent(out), optional :: success
     integer :: i_bin
     call observable_record_value (h%obs, value)
     if (h%width /= 0) then
        i_bin = floor (((value - h%lower_bound) / h%width) * h%n_bins) + 1
     else
        i_bin = 0
     end if
     if (i_bin <= 0) then
        call bin_record_value (h%underflow, .false., 1._default, excess)
        if (present (success))  success = .false.
     else if (i_bin <= h%n_bins) then
        call observable_record_value (h%obs_within_bounds, value)
        call bin_record_value &
             (h%bin(i_bin), h%normalize_bins, 1._default, excess)
        if (present (success))  success = .true.
     else
        call bin_record_value (h%overflow, .false., 1._default, excess)
        if (present (success))  success = .false.
     end if
   end subroutine histogram_record_value_unweighted
 
 @ %def histogram_record_value_unweighted
 @ Weighted events: analogous, but no excess weight.
 <<Analysis: procedures>>=
   subroutine histogram_record_value_weighted (h, value, weight, success)
     type(histogram_t), intent(inout) :: h
     real(default), intent(in) :: value, weight
     logical, intent(out), optional :: success
     integer :: i_bin
     call observable_record_value (h%obs, value, weight)
     if (h%width /= 0) then
        i_bin = floor (((value - h%lower_bound) / h%width) * h%n_bins) + 1
     else
        i_bin = 0
     end if
     if (i_bin <= 0) then
        call bin_record_value (h%underflow, .false., weight)
        if (present (success))  success = .false.
     else if (i_bin <= h%n_bins) then
        call observable_record_value (h%obs_within_bounds, value, weight)
        call bin_record_value (h%bin(i_bin), h%normalize_bins, weight)
        if (present (success))  success = .true.
     else
        call bin_record_value (h%overflow, .false., weight)
        if (present (success))  success = .false.
     end if
   end subroutine histogram_record_value_weighted
 
 @ %def histogram_record_value_weighted
 @
 \subsubsection{Access contents}
 Inherited from the observable component (all-over average etc.)
 <<Analysis: procedures>>=
   function histogram_get_n_entries (h) result (n)
     integer :: n
     type(histogram_t), intent(in) :: h
     n = observable_get_n_entries (h%obs)
   end function histogram_get_n_entries
 
   function histogram_get_average (h) result (avg)
     real(default) :: avg
     type(histogram_t), intent(in) :: h
     avg = observable_get_average (h%obs)
   end function histogram_get_average
 
   function histogram_get_error (h) result (err)
     real(default) :: err
     type(histogram_t), intent(in) :: h
     err = observable_get_error (h%obs)
   end function histogram_get_error
 
 @ %def histogram_get_n_entries
 @ %def histogram_get_average
 @ %def histogram_get_error
 @ Analogous, but applied only to events within bounds.
 <<Analysis: procedures>>=
   function histogram_get_n_entries_within_bounds (h) result (n)
     integer :: n
     type(histogram_t), intent(in) :: h
     n = observable_get_n_entries (h%obs_within_bounds)
   end function histogram_get_n_entries_within_bounds
 
   function histogram_get_average_within_bounds (h) result (avg)
     real(default) :: avg
     type(histogram_t), intent(in) :: h
     avg = observable_get_average (h%obs_within_bounds)
   end function histogram_get_average_within_bounds
 
   function histogram_get_error_within_bounds (h) result (err)
     real(default) :: err
     type(histogram_t), intent(in) :: h
     err = observable_get_error (h%obs_within_bounds)
   end function histogram_get_error_within_bounds
 
 @ %def histogram_get_n_entries_within_bounds
 @ %def histogram_get_average_within_bounds
 @ %def histogram_get_error_within_bounds
 Get the number of bins
 <<Analysis: procedures>>=
   function histogram_get_n_bins (h) result (n)
     type(histogram_t), intent(in) :: h
     integer :: n
     n = h%n_bins
   end function histogram_get_n_bins
 
 @ %def histogram_get_n_bins
 @ Check bins.  If the index is zero or above the limit, return the
 results for underflow or overflow, respectively.
 <<Analysis: procedures>>=
   function histogram_get_n_entries_for_bin (h, i) result (n)
     integer :: n
     type(histogram_t), intent(in) :: h
     integer, intent(in) :: i
     if (i <= 0) then
        n = bin_get_n_entries (h%underflow)
     else if (i <= h%n_bins) then
        n = bin_get_n_entries (h%bin(i))
     else
        n = bin_get_n_entries (h%overflow)
     end if
   end function histogram_get_n_entries_for_bin
 
   function histogram_get_sum_for_bin (h, i) result (avg)
     real(default) :: avg
     type(histogram_t), intent(in) :: h
     integer, intent(in) :: i
     if (i <= 0) then
        avg = bin_get_sum (h%underflow)
     else if (i <= h%n_bins) then
        avg = bin_get_sum (h%bin(i))
     else
        avg = bin_get_sum (h%overflow)
     end if
   end function histogram_get_sum_for_bin
 
   function histogram_get_error_for_bin (h, i) result (err)
     real(default) :: err
     type(histogram_t), intent(in) :: h
     integer, intent(in) :: i
     if (i <= 0) then
        err = bin_get_error (h%underflow)
     else if (i <= h%n_bins) then
        err = bin_get_error (h%bin(i))
     else
        err = bin_get_error (h%overflow)
     end if
   end function histogram_get_error_for_bin
 
   function histogram_get_excess_for_bin (h, i) result (err)
     real(default) :: err
     type(histogram_t), intent(in) :: h
     integer, intent(in) :: i
     if (i <= 0) then
        err = bin_get_excess (h%underflow)
     else if (i <= h%n_bins) then
        err = bin_get_excess (h%bin(i))
     else
        err = bin_get_excess (h%overflow)
     end if
   end function histogram_get_excess_for_bin
 
 @ %def histogram_get_n_entries_for_bin
 @ %def histogram_get_sum_for_bin
 @ %def histogram_get_error_for_bin
 @ %def histogram_get_excess_for_bin
 @ Return a pointer to the graph options.
 <<Analysis: procedures>>=
   function histogram_get_graph_options_ptr (h) result (ptr)
     type(graph_options_t), pointer :: ptr
     type(histogram_t), intent(in), target :: h
     ptr => h%graph_options
   end function histogram_get_graph_options_ptr
 
 @ %def histogram_get_graph_options_ptr
 @ Return a pointer to the drawing options.
 <<Analysis: procedures>>=
   function histogram_get_drawing_options_ptr (h) result (ptr)
     type(drawing_options_t), pointer :: ptr
     type(histogram_t), intent(in), target :: h
     ptr => h%drawing_options
   end function histogram_get_drawing_options_ptr
 
 @ %def histogram_get_drawing_options_ptr
 @
 \subsubsection{Output}
 <<Analysis: procedures>>=
   subroutine histogram_write (h, unit)
     type(histogram_t), intent(in) :: h
     integer, intent(in), optional :: unit
     integer :: u, i
     u = given_output_unit (unit);  if (u < 0)  return
     call bin_write_header (u)
     if (allocated (h%bin)) then
        do i = 1, h%n_bins
           call bin_write (h%bin(i), u)
        end do
     end if
     write (u, "(A)")
     write (u, "(A,1x,A)")  "#", "Underflow:"
     call bin_write (h%underflow, u)
     write (u, "(A)")
     write (u, "(A,1x,A)")  "#", "Overflow:"
     call bin_write (h%overflow, u)
     write (u, "(A)")
     write (u, "(A,1x,A)")  "#", "Summary: data within bounds"
     call observable_write (h%obs_within_bounds, u)
     write (u, "(A)")
     write (u, "(A,1x,A)")  "#", "Summary: all data"
     call observable_write (h%obs, u)
     write (u, "(A)")
   end subroutine histogram_write
 
 @ %def histogram_write
 @ Write the GAMELAN reader for histogram contents.
 <<Analysis: procedures>>=
   subroutine histogram_write_gml_reader (h, filename, unit)
     type(histogram_t), intent(in) :: h
     type(string_t), intent(in) :: filename
     integer, intent(in), optional :: unit
     character(*), parameter :: fmt = "(ES15.8)"
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     write (u, "(2x,A)")  'fromfile "' // char (filename) // '":'
     write (u, "(4x,A)")  'key "# Histogram:";'
     write (u, "(4x,A)")  'dx := #' &
          // real2char (h%width / h%n_bins / 2, fmt) // ';'
     write (u, "(4x,A)")  'for i withinblock:'
     write (u, "(6x,A)")  'get x, y, y.d, y.n, y.e;'
     if (h%drawing_options%with_hbars) then
        write (u, "(6x,A)")  'plot (' // char (h%drawing_options%dataset) &
             // ') (x,y) hbar dx;'
     else
        write (u, "(6x,A)")  'plot (' // char (h%drawing_options%dataset) &
             // ') (x,y);'
     end if
     if (h%drawing_options%err) then
        write (u, "(6x,A)")  'plot (' // char (h%drawing_options%dataset) &
          // '.err) ' &
             // '(x,y) vbar y.d;'
     end if
     !!! Future excess options for plots
     ! write (u, "(6x,A)")  'if show_excess: ' // &
     !            & 'plot(dat.e)(x, y plus y.e) hbar dx; fi'
     write (u, "(4x,A)")  'endfor'
     write (u, "(2x,A)")  'endfrom'
   end subroutine histogram_write_gml_reader
 
 @ %def histogram_write_gml_reader
 @ \LaTeX\ and GAMELAN output.
 <<Analysis: procedures>>=
   subroutine histogram_write_gml_driver (h, filename, unit)
     type(histogram_t), intent(in) :: h
     type(string_t), intent(in) :: filename
     integer, intent(in), optional :: unit
     type(string_t) :: calc_cmd, bg_cmd, draw_cmd, err_cmd, symb_cmd, fg_cmd
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     call graph_options_write_tex_header (h%graph_options, unit)
     write (u, "(2x,A)")  char (graph_options_get_gml_setup (h%graph_options))
     write (u, "(2x,A)")  char (graph_options_get_gml_graphrange &
          (h%graph_options, x_min=h%lower_bound, x_max=h%upper_bound))
     call histogram_write_gml_reader (h, filename, unit)
     calc_cmd = drawing_options_get_calc_command (h%drawing_options)
     if (calc_cmd /= "")  write (u, "(2x,A)")  char (calc_cmd)
     bg_cmd = drawing_options_get_gml_bg_command (h%drawing_options)
     if (bg_cmd /= "")  write (u, "(2x,A)")  char (bg_cmd)
     draw_cmd = drawing_options_get_draw_command (h%drawing_options)
     if (draw_cmd /= "")  write (u, "(2x,A)")  char (draw_cmd)
     err_cmd = drawing_options_get_err_command (h%drawing_options)
     if (err_cmd /= "")  write (u, "(2x,A)")  char (err_cmd)
     symb_cmd = drawing_options_get_symb_command (h%drawing_options)
     if (symb_cmd /= "")  write (u, "(2x,A)")  char (symb_cmd)
     fg_cmd = drawing_options_get_gml_fg_command (h%drawing_options)
     if (fg_cmd /= "")  write (u, "(2x,A)")  char (fg_cmd)
     write (u, "(2x,A)")  char (graph_options_get_gml_x_label (h%graph_options))
     write (u, "(2x,A)")  char (graph_options_get_gml_y_label (h%graph_options))
     call graph_options_write_tex_footer (h%graph_options, unit)
     write (u, "(A)") "\vspace*{2\baselineskip}"
     write (u, "(A)") "\begin{flushleft}"
     write (u, "(A)") "\textbf{Data within bounds:} \\"
     call observable_write_driver (h%obs_within_bounds, unit, &
                                   write_heading=.false.)
     write (u, "(A)") "\\[0.5\baselineskip]"
     write (u, "(A)") "\textbf{All data:} \\"
     call observable_write_driver (h%obs, unit, write_heading=.false.)
     write (u, "(A)") "\end{flushleft}"
   end subroutine histogram_write_gml_driver
 
 @ %def histogram_write_gml_driver
 @ Return the header for generic data output as an ifile.
 <<Analysis: procedures>>=
   subroutine histogram_get_header (h, header, comment)
     type(histogram_t), intent(in) :: h
     type(ifile_t), intent(inout) :: header
     type(string_t), intent(in), optional :: comment
     type(string_t) :: c
     if (present (comment)) then
        c = comment
     else
        c = ""
     end if
     call ifile_append (header, c // "WHIZARD histogram data")
     call graph_options_get_header (h%graph_options, header, comment)
     call ifile_append (header, &
          c // "range: " // real2string (h%lower_bound) &
          // " - " // real2string (h%upper_bound))
     call ifile_append (header, &
          c // "counts total: " &
          // int2char (histogram_get_n_entries_within_bounds (h)))
     call ifile_append (header, &
          c // "total average: " &
          // real2string (histogram_get_average_within_bounds (h)) // " +- " &
          // real2string (histogram_get_error_within_bounds (h)))
   end subroutine histogram_get_header
 
 @ %def histogram_get_header
 @
 \subsection{Plots}
 \subsubsection{Points}
 <<Analysis: types>>=
   type :: point_t
      private
      real(default) :: x = 0
      real(default) :: y = 0
      real(default) :: yerr = 0
      real(default) :: xerr = 0
      type(point_t), pointer :: next => null ()
   end type point_t
 
 @ %def point_t
 <<Analysis: interfaces>>=
   interface point_init
     module procedure point_init_contents
     module procedure point_init_point
   end interface
 <<Analysis: procedures>>=
   subroutine point_init_contents (point, x, y, yerr, xerr)
     type(point_t), intent(out) :: point
     real(default), intent(in) :: x, y
     real(default), intent(in), optional :: yerr, xerr
     point%x = x
     point%y = y
     if (present (yerr))  point%yerr = yerr
     if (present (xerr))  point%xerr = xerr
   end subroutine point_init_contents
 
   subroutine point_init_point (point, point_in)
     type(point_t), intent(out) :: point
     type(point_t), intent(in) :: point_in
     point%x = point_in%x
     point%y = point_in%y
     point%yerr = point_in%yerr
     point%xerr = point_in%xerr
   end subroutine point_init_point
 
 @ %def point_init
 <<Analysis: procedures>>=
   function point_get_x (point) result (x)
     real(default) :: x
     type(point_t), intent(in) :: point
     x = point%x
   end function point_get_x
 
   function point_get_y (point) result (y)
     real(default) :: y
     type(point_t), intent(in) :: point
     y = point%y
   end function point_get_y
 
   function point_get_xerr (point) result (xerr)
     real(default) :: xerr
     type(point_t), intent(in) :: point
     xerr = point%xerr
   end function point_get_xerr
 
   function point_get_yerr (point) result (yerr)
     real(default) :: yerr
     type(point_t), intent(in) :: point
     yerr = point%yerr
   end function point_get_yerr
 
 @ %def point_get_x
 @ %def point_get_y
 @ %def point_get_xerr
 @ %def point_get_yerr
 <<Analysis: procedures>>=
   subroutine point_write_header (unit)
     integer, intent(in) :: unit
     character(120) :: buffer
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     write (buffer, "(A,4(1x," // HISTOGRAM_HEAD_FORMAT // "))") &
          "#", "x       ", "y       ", "yerr     ", "xerr     "
     write (u, "(A)")  trim (buffer)
   end subroutine point_write_header
 
   subroutine point_write (point, unit)
     type(point_t), intent(in) :: point
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     write (u, "(1x,4(1x," // HISTOGRAM_DATA_FORMAT // "))") &
          point_get_x (point), &
          point_get_y (point), &
          point_get_yerr (point), &
          point_get_xerr (point)
   end subroutine point_write
 
 @ %def point_write
 @
 \subsubsection{Plots}
 <<Analysis: types>>=
   type :: plot_t
      private
      type(point_t), pointer :: first => null ()
      type(point_t), pointer :: last => null ()
      integer :: count = 0
      type(graph_options_t) :: graph_options
      type(drawing_options_t) :: drawing_options
   end type plot_t
 
 @ %def plot_t
 @
 \subsubsection{Initializer/finalizer}
 Initialize a plot.  We provide the lower and upper bound in the $x$
 direction.
 <<Analysis: interfaces>>=
   interface plot_init
      module procedure plot_init_empty
      module procedure plot_init_plot
   end interface
 <<Analysis: procedures>>=
   subroutine plot_init_empty (p, id, graph_options, drawing_options)
     type(plot_t), intent(out) :: p
     type(string_t), intent(in) :: id
     type(graph_options_t), intent(in), optional :: graph_options
     type(drawing_options_t), intent(in), optional :: drawing_options
     if (present (graph_options)) then
        p%graph_options = graph_options
     else
        call graph_options_init (p%graph_options)
     end if
     call graph_options_set (p%graph_options, id = id)
     if (present (drawing_options)) then
        p%drawing_options = drawing_options
     else
        call drawing_options_init_plot (p%drawing_options)
     end if
   end subroutine plot_init_empty
 
 @ %def plot_init
 @ Initialize a plot by copying another one, optionally merging in a new
 set of drawing options.
 
 Since [[p]] has pointer (sub)components, we have to explicitly deep-copy the
 original.
 <<Analysis: procedures>>=
   subroutine plot_init_plot (p, p_in, drawing_options)
     type(plot_t), intent(out) :: p
     type(plot_t), intent(in) :: p_in
     type(drawing_options_t), intent(in), optional :: drawing_options
     type(point_t), pointer :: current, new
     current => p_in%first
     do while (associated (current))
        allocate (new)
        call point_init (new, current)
        if (associated (p%last)) then
           p%last%next => new
        else
           p%first => new
        end if
        p%last => new
        current => current%next
     end do
     p%count = p_in%count
     p%graph_options = p_in%graph_options
     if (present (drawing_options)) then
        p%drawing_options = drawing_options
     else
        p%drawing_options = p_in%drawing_options
     end if
   end subroutine plot_init_plot
 
 @ %def plot_init_plot
 @ Finalize the plot by deallocating the list of points.
 <<Analysis: procedures>>=
   subroutine plot_final (plot)
     type(plot_t), intent(inout) :: plot
     type(point_t), pointer :: current
     do while (associated (plot%first))
        current => plot%first
        plot%first => current%next
        deallocate (current)
     end do
     plot%last => null ()
   end subroutine plot_final
 
 @ %def plot_final
 @
 \subsubsection{Fill plots}
 Clear the plot contents, but do not modify the structure.
 <<Analysis: procedures>>=
   subroutine plot_clear (plot)
     type(plot_t), intent(inout) :: plot
     plot%count = 0
     call plot_final (plot)
   end subroutine plot_clear
 
 @ %def plot_clear
 @ Record a value.  Successful if the value is within bounds, otherwise
 it is recorded as under-/overflow.
 <<Analysis: procedures>>=
   subroutine plot_record_value (plot, x, y, yerr, xerr, success)
     type(plot_t), intent(inout) :: plot
     real(default), intent(in) :: x, y
     real(default), intent(in), optional :: yerr, xerr
     logical, intent(out), optional :: success
     type(point_t), pointer :: point
     plot%count = plot%count + 1
     allocate (point)
     call point_init (point, x, y, yerr, xerr)
     if (associated (plot%first)) then
        plot%last%next => point
     else
        plot%first => point
     end if
     plot%last => point
     if (present (success))  success = .true.
   end subroutine plot_record_value
 
 @ %def plot_record_value
 @
 \subsubsection{Access contents}
 The number of points.
 <<Analysis: procedures>>=
   function plot_get_n_entries (plot) result (n)
     integer :: n
     type(plot_t), intent(in) :: plot
     n = plot%count
   end function plot_get_n_entries
 
 @ %def plot_get_n_entries
 @ Return a pointer to the graph options.
 <<Analysis: procedures>>=
   function plot_get_graph_options_ptr (p) result (ptr)
     type(graph_options_t), pointer :: ptr
     type(plot_t), intent(in), target :: p
     ptr => p%graph_options
   end function plot_get_graph_options_ptr
 
 @ %def plot_get_graph_options_ptr
 @ Return a pointer to the drawing options.
 <<Analysis: procedures>>=
   function plot_get_drawing_options_ptr (p) result (ptr)
     type(drawing_options_t), pointer :: ptr
     type(plot_t), intent(in), target :: p
     ptr => p%drawing_options
   end function plot_get_drawing_options_ptr
 
 @ %def plot_get_drawing_options_ptr
 @
 \subsubsection{Output}
 This output format is used by the GAMELAN driver below.
 <<Analysis: procedures>>=
   subroutine plot_write (plot, unit)
     type(plot_t), intent(in) :: plot
     integer, intent(in), optional :: unit
     type(point_t), pointer :: point
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     call point_write_header (u)
     point => plot%first
     do while (associated (point))
        call point_write (point, unit)
        point => point%next
     end do
     write (u, *)
     write (u, "(A,1x,A)")  "#", "Summary:"
     write (u, "(A,1x,I0)") &
          "n_entries =", plot_get_n_entries (plot)
     write (u, *)
   end subroutine plot_write
 
 @ %def plot_write
 @ Write the GAMELAN reader for plot contents.
 <<Analysis: procedures>>=
   subroutine plot_write_gml_reader (p, filename, unit)
     type(plot_t), intent(in) :: p
     type(string_t), intent(in) :: filename
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     write (u, "(2x,A)")  'fromfile "' // char (filename) // '":'
     write (u, "(4x,A)")  'key "# Plot:";'
     write (u, "(4x,A)")  'for i withinblock:'
     write (u, "(6x,A)")  'get x, y, y.err, x.err;'
     write (u, "(6x,A)")  'plot (' // char (p%drawing_options%dataset) &
          // ') (x,y);'
     if (p%drawing_options%err) then
        write (u, "(6x,A)")  'plot (' // char (p%drawing_options%dataset) &
             // '.err) (x,y) vbar y.err hbar x.err;'
     end if
     write (u, "(4x,A)")  'endfor'
     write (u, "(2x,A)")  'endfrom'
   end subroutine plot_write_gml_reader
 
 @ %def plot_write_gml_header
 @ \LaTeX\ and GAMELAN output.  Analogous to histogram output.
 <<Analysis: procedures>>=
   subroutine plot_write_gml_driver (p, filename, unit)
     type(plot_t), intent(in) :: p
     type(string_t), intent(in) :: filename
     integer, intent(in), optional :: unit
     type(string_t) :: calc_cmd, bg_cmd, draw_cmd, err_cmd, symb_cmd, fg_cmd
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     call graph_options_write_tex_header (p%graph_options, unit)
     write (u, "(2x,A)") &
          char (graph_options_get_gml_setup (p%graph_options))
     write (u, "(2x,A)") &
          char (graph_options_get_gml_graphrange (p%graph_options))
     call plot_write_gml_reader (p, filename, unit)
     calc_cmd = drawing_options_get_calc_command (p%drawing_options)
     if (calc_cmd /= "")  write (u, "(2x,A)")  char (calc_cmd)
     bg_cmd = drawing_options_get_gml_bg_command (p%drawing_options)
     if (bg_cmd /= "")  write (u, "(2x,A)")  char (bg_cmd)
     draw_cmd = drawing_options_get_draw_command (p%drawing_options)
     if (draw_cmd /= "")  write (u, "(2x,A)")  char (draw_cmd)
     err_cmd = drawing_options_get_err_command (p%drawing_options)
     if (err_cmd /= "")  write (u, "(2x,A)")  char (err_cmd)
     symb_cmd = drawing_options_get_symb_command (p%drawing_options)
     if (symb_cmd /= "")  write (u, "(2x,A)")  char (symb_cmd)
     fg_cmd = drawing_options_get_gml_fg_command (p%drawing_options)
     if (fg_cmd /= "")  write (u, "(2x,A)")  char (fg_cmd)
     write (u, "(2x,A)")  char (graph_options_get_gml_x_label (p%graph_options))
     write (u, "(2x,A)")  char (graph_options_get_gml_y_label (p%graph_options))
     call graph_options_write_tex_footer (p%graph_options, unit)
   end subroutine plot_write_gml_driver
 
 @ %def plot_write_driver
 @ Append header for generic data output in ifile format.
 <<Analysis: procedures>>=
   subroutine plot_get_header (plot, header, comment)
     type(plot_t), intent(in) :: plot
     type(ifile_t), intent(inout) :: header
     type(string_t), intent(in), optional :: comment
     type(string_t) :: c
     if (present (comment)) then
        c = comment
     else
        c = ""
     end if
     call ifile_append (header, c // "WHIZARD plot data")
     call graph_options_get_header (plot%graph_options, header, comment)
     call ifile_append (header, &
          c // "number of points: " &
          // int2char (plot_get_n_entries (plot)))
   end subroutine plot_get_header
 
 @ %def plot_get_header
 @
 \subsection{Graphs}
 A graph is a container for several graph elements.  Each graph element is
 either a plot or a histogram.  There is an appropriate base type below
 (the [[analysis_object_t]]), but to avoid recursion, we define a separate base
 type here.  Note that there is no actual recursion: a graph is an analysis
 object, but a graph cannot contain graphs.
 
 (If we could use type extension, the implementation would be much more
 transparent.)
 
 \subsubsection{Graph elements}
 Graph elements cannot be filled by the [[record]] command directly.  The
 contents are always copied from elementary histograms or plots.
 <<Analysis: types>>=
   type :: graph_element_t
      private
      integer :: type = AN_UNDEFINED
      type(histogram_t), pointer :: h => null ()
      type(plot_t), pointer :: p => null ()
   end type graph_element_t
 
 @ %def graph_element_t
 <<Analysis: procedures>>=
   subroutine graph_element_final (el)
     type(graph_element_t), intent(inout) :: el
     select case (el%type)
     case (AN_HISTOGRAM)
        deallocate (el%h)
     case (AN_PLOT)
        call plot_final (el%p)
        deallocate (el%p)
     end select
     el%type = AN_UNDEFINED
   end subroutine graph_element_final
 
 @ %def graph_element_final
 @ Return the number of entries in the graph element:
 <<Analysis: procedures>>=
   function graph_element_get_n_entries (el) result (n)
     integer :: n
     type(graph_element_t), intent(in) :: el
     select case (el%type)
     case (AN_HISTOGRAM);  n = histogram_get_n_entries (el%h)
     case (AN_PLOT);       n = plot_get_n_entries (el%p)
     case default;         n = 0
     end select
   end function graph_element_get_n_entries
 
 @ %def graph_element_get_n_entries
 @ Return a pointer to the graph / drawing options.
 <<Analysis: procedures>>=
   function graph_element_get_graph_options_ptr (el) result (ptr)
     type(graph_options_t), pointer :: ptr
     type(graph_element_t), intent(in) :: el
     select case (el%type)
     case (AN_HISTOGRAM);  ptr => histogram_get_graph_options_ptr (el%h)
     case (AN_PLOT);       ptr => plot_get_graph_options_ptr (el%p)
     case default;         ptr => null ()
     end select
   end function graph_element_get_graph_options_ptr
 
   function graph_element_get_drawing_options_ptr (el) result (ptr)
     type(drawing_options_t), pointer :: ptr
     type(graph_element_t), intent(in) :: el
     select case (el%type)
     case (AN_HISTOGRAM);  ptr => histogram_get_drawing_options_ptr (el%h)
     case (AN_PLOT);       ptr => plot_get_drawing_options_ptr (el%p)
     case default;         ptr => null ()
     end select
   end function graph_element_get_drawing_options_ptr
 
 @ %def graph_element_get_graph_options_ptr
 @ %def graph_element_get_drawing_options_ptr
 @ Output, simple wrapper for the plot/histogram writer.
 <<Analysis: procedures>>=
   subroutine graph_element_write (el, unit)
     type(graph_element_t), intent(in) :: el
     integer, intent(in), optional :: unit
     type(graph_options_t), pointer :: gro
     type(string_t) :: id
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     gro => graph_element_get_graph_options_ptr (el)
     id = graph_options_get_id (gro)
     write (u, "(A,A)")  '#', repeat ("-", 78)
     select case (el%type)
     case (AN_HISTOGRAM)
        write (u, "(A)", advance="no")  "# Histogram: "
        write (u, "(1x,A)")  char (id)
        call histogram_write (el%h, unit)
     case (AN_PLOT)
        write (u, "(A)", advance="no")  "# Plot: "
        write (u, "(1x,A)")  char (id)
        call plot_write (el%p, unit)
     end select
   end subroutine graph_element_write
 
 @ %def graph_element_write
 <<Analysis: procedures>>=
   subroutine graph_element_write_gml_reader (el, filename, unit)
     type(graph_element_t), intent(in) :: el
     type(string_t), intent(in) :: filename
     integer, intent(in), optional :: unit
     select case (el%type)
     case (AN_HISTOGRAM);  call histogram_write_gml_reader (el%h, filename, unit)
     case (AN_PLOT);       call plot_write_gml_reader (el%p, filename, unit)
     end select
   end subroutine graph_element_write_gml_reader
 
 @ %def graph_element_write_gml_reader
 @
 \subsubsection{The graph type}
 The actual graph type contains its own [[graph_options]], which override the
 individual settings.  The [[drawing_options]] are set in the graph elements.
 This distinction motivates the separation of the two types.
 <<Analysis: types>>=
   type :: graph_t
      private
      type(graph_element_t), dimension(:), allocatable :: el
      type(graph_options_t) :: graph_options
   end type graph_t
 
 @ %def graph_t
 @
 \subsubsection{Initializer/finalizer}
 The graph is created with a definite number of elements.  The elements are
 filled one by one, optionally with modified drawing options.
 <<Analysis: procedures>>=
   subroutine graph_init (g, id, n_elements, graph_options)
     type(graph_t), intent(out) :: g
     type(string_t), intent(in) :: id
     integer, intent(in) :: n_elements
     type(graph_options_t), intent(in), optional :: graph_options
     allocate (g%el (n_elements))
     if (present (graph_options)) then
        g%graph_options = graph_options
     else
        call graph_options_init (g%graph_options)
     end if
     call graph_options_set (g%graph_options, id = id)
   end subroutine graph_init
 
 @ %def graph_init
 <<Analysis: procedures>>=
   subroutine graph_insert_histogram (g, i, h, drawing_options)
     type(graph_t), intent(inout), target :: g
     integer, intent(in) :: i
     type(histogram_t), intent(in) :: h
     type(drawing_options_t), intent(in), optional :: drawing_options
     type(graph_options_t), pointer :: gro
     type(drawing_options_t), pointer :: dro
     type(string_t) :: id
     g%el(i)%type = AN_HISTOGRAM
     allocate (g%el(i)%h)
     call histogram_init_histogram (g%el(i)%h, h, drawing_options)
     gro => histogram_get_graph_options_ptr (g%el(i)%h)
     dro => histogram_get_drawing_options_ptr (g%el(i)%h)
     id = graph_options_get_id (gro)
     call drawing_options_set (dro, dataset = "dat." // id)
   end subroutine graph_insert_histogram
 
 @ %def graph_insert_histogram
 <<Analysis: procedures>>=
   subroutine graph_insert_plot (g, i, p, drawing_options)
     type(graph_t), intent(inout) :: g
     integer, intent(in) :: i
     type(plot_t), intent(in) :: p
     type(drawing_options_t), intent(in), optional :: drawing_options
     type(graph_options_t), pointer :: gro
     type(drawing_options_t), pointer :: dro
     type(string_t) :: id
     g%el(i)%type = AN_PLOT
     allocate (g%el(i)%p)
     call plot_init_plot (g%el(i)%p, p, drawing_options)
     gro => plot_get_graph_options_ptr (g%el(i)%p)
     dro => plot_get_drawing_options_ptr (g%el(i)%p)
     id = graph_options_get_id (gro)
     call drawing_options_set (dro, dataset = "dat." // id)
   end subroutine graph_insert_plot
 
 @ %def graph_insert_plot
 @ Finalizer.
 <<Analysis: procedures>>=
   subroutine graph_final (g)
     type(graph_t), intent(inout) :: g
     integer :: i
     do i = 1, size (g%el)
        call graph_element_final (g%el(i))
     end do
     deallocate (g%el)
   end subroutine graph_final
 
 @ %def graph_final
 @
 \subsubsection{Access contents}
 The number of elements.
 <<Analysis: procedures>>=
   function graph_get_n_elements (graph) result (n)
     integer :: n
     type(graph_t), intent(in) :: graph
     n = size (graph%el)
   end function graph_get_n_elements
 
 @ %def graph_get_n_elements
 @ Retrieve a pointer to the drawing options of an element, so they can be
 modified.  (The [[target]] attribute is not actually needed because the
 components are pointers.)
 <<Analysis: procedures>>=
   function graph_get_drawing_options_ptr (g, i) result (ptr)
     type(drawing_options_t), pointer :: ptr
     type(graph_t), intent(in), target :: g
     integer, intent(in) :: i
     ptr => graph_element_get_drawing_options_ptr (g%el(i))
   end function graph_get_drawing_options_ptr
 
 @ %def graph_get_drawing_options_ptr
 @
 \subsubsection{Output}
 The default output format just writes histogram and plot data.
 <<Analysis: procedures>>=
   subroutine graph_write (graph, unit)
     type(graph_t), intent(in) :: graph
     integer, intent(in), optional :: unit
     integer :: i
     do i = 1, size (graph%el)
        call graph_element_write (graph%el(i), unit)
     end do
   end subroutine graph_write
 
 @ %def graph_write
 @ The GAMELAN driver is not a simple wrapper, but it writes the plot/histogram
 contents embedded the complete graph.  First, data are read in, global
 background commands next, then individual elements, then global foreground
 commands.
 <<Analysis: procedures>>=
   subroutine graph_write_gml_driver (g, filename, unit)
     type(graph_t), intent(in) :: g
     type(string_t), intent(in) :: filename
     type(string_t) :: calc_cmd, bg_cmd, draw_cmd, err_cmd, symb_cmd, fg_cmd
     integer, intent(in), optional :: unit
     type(drawing_options_t), pointer :: dro
     integer :: u, i
     u = given_output_unit (unit);  if (u < 0)  return
     call graph_options_write_tex_header (g%graph_options, unit)
     write (u, "(2x,A)") &
          char (graph_options_get_gml_setup (g%graph_options))
     write (u, "(2x,A)") &
          char (graph_options_get_gml_graphrange (g%graph_options))
     do i = 1, size (g%el)
        call graph_element_write_gml_reader (g%el(i), filename, unit)
        calc_cmd = drawing_options_get_calc_command &
                        (graph_element_get_drawing_options_ptr (g%el(i)))
        if (calc_cmd /= "")  write (u, "(2x,A)")  char (calc_cmd)
     end do
     bg_cmd = graph_options_get_gml_bg_command (g%graph_options)
     if (bg_cmd /= "")  write (u, "(2x,A)")  char (bg_cmd)
     do i = 1, size (g%el)
        dro => graph_element_get_drawing_options_ptr (g%el(i))
        bg_cmd = drawing_options_get_gml_bg_command (dro)
        if (bg_cmd /= "")  write (u, "(2x,A)")  char (bg_cmd)
        draw_cmd = drawing_options_get_draw_command (dro)
        if (draw_cmd /= "")  write (u, "(2x,A)")  char (draw_cmd)
        err_cmd = drawing_options_get_err_command (dro)
        if (err_cmd /= "")  write (u, "(2x,A)")  char (err_cmd)
        symb_cmd = drawing_options_get_symb_command (dro)
        if (symb_cmd /= "")  write (u, "(2x,A)")  char (symb_cmd)
        fg_cmd = drawing_options_get_gml_fg_command (dro)
        if (fg_cmd /= "")  write (u, "(2x,A)")  char (fg_cmd)
     end do
     fg_cmd = graph_options_get_gml_fg_command (g%graph_options)
     if (fg_cmd /= "")  write (u, "(2x,A)")  char (fg_cmd)
     write (u, "(2x,A)")  char (graph_options_get_gml_x_label (g%graph_options))
     write (u, "(2x,A)")  char (graph_options_get_gml_y_label (g%graph_options))
     call graph_options_write_tex_footer (g%graph_options, unit)
   end subroutine graph_write_gml_driver
 
 @ %def graph_write_gml_driver
 @ Append header for generic data output in ifile format.
 <<Analysis: procedures>>=
   subroutine graph_get_header (graph, header, comment)
     type(graph_t), intent(in) :: graph
     type(ifile_t), intent(inout) :: header
     type(string_t), intent(in), optional :: comment
     type(string_t) :: c
     if (present (comment)) then
        c = comment
     else
        c = ""
     end if
     call ifile_append (header, c // "WHIZARD graph data")
     call graph_options_get_header (graph%graph_options, header, comment)
     call ifile_append (header, &
          c // "number of graph elements: " &
          // int2char (graph_get_n_elements (graph)))
   end subroutine graph_get_header
 
 @ %def graph_get_header
 @
 \subsection{Analysis objects}
 This data structure holds all observables, histograms and such that
 are currently active.  We have one global store; individual items are
 identified by their ID strings.
 
 (This should rather be coded by type extension.)
 <<Analysis: parameters>>=
   integer, parameter :: AN_UNDEFINED = 0
   integer, parameter :: AN_OBSERVABLE = 1
   integer, parameter :: AN_HISTOGRAM = 2
   integer, parameter :: AN_PLOT = 3
   integer, parameter :: AN_GRAPH = 4
 <<Analysis: public>>=
   public :: AN_UNDEFINED, AN_HISTOGRAM, AN_OBSERVABLE, AN_PLOT, AN_GRAPH
 
 @ %def AN_UNDEFINED
 @ %def AN_OBSERVABLE AN_HISTOGRAM AN_PLOT AN_GRAPH
 <<Analysis: types>>=
   type :: analysis_object_t
      private
      type(string_t) :: id
      integer :: type = AN_UNDEFINED
      type(observable_t), pointer :: obs => null ()
      type(histogram_t), pointer :: h => null ()
      type(plot_t), pointer :: p => null ()
      type(graph_t), pointer :: g => null ()
      type(analysis_object_t), pointer :: next => null ()
   end type analysis_object_t
 
 @ %def analysis_object_t
 @
 \subsubsection{Initializer/finalizer}
 Allocate with the correct type but do not fill initial values.
 <<Analysis: procedures>>=
   subroutine analysis_object_init (obj, id, type)
     type(analysis_object_t), intent(out) :: obj
     type(string_t), intent(in) :: id
     integer, intent(in) :: type
     obj%id = id
     obj%type = type
     select case (obj%type)
     case (AN_OBSERVABLE);  allocate (obj%obs)
     case (AN_HISTOGRAM);   allocate (obj%h)
     case (AN_PLOT);        allocate (obj%p)
     case (AN_GRAPH);       allocate (obj%g)
     end select
   end subroutine analysis_object_init
 
 @ %def analysis_object_init
 <<Analysis: procedures>>=
   subroutine analysis_object_final (obj)
     type(analysis_object_t), intent(inout) :: obj
     select case (obj%type)
     case (AN_OBSERVABLE)
        deallocate (obj%obs)
     case (AN_HISTOGRAM)
        deallocate (obj%h)
     case (AN_PLOT)
        call plot_final (obj%p)
        deallocate (obj%p)
     case (AN_GRAPH)
        call graph_final (obj%g)
        deallocate (obj%g)
     end select
     obj%type = AN_UNDEFINED
   end subroutine analysis_object_final
 
 @ %def analysis_object_final
 @ Clear the analysis object, i.e., reset it to its initial state.  Not
 applicable to graphs, which are always combinations of other existing
 objects.
 <<Analysis: procedures>>=
   subroutine analysis_object_clear (obj)
     type(analysis_object_t), intent(inout) :: obj
     select case (obj%type)
     case (AN_OBSERVABLE)
        call observable_clear (obj%obs)
     case (AN_HISTOGRAM)
        call histogram_clear (obj%h)
     case (AN_PLOT)
        call plot_clear (obj%p)
     end select
   end subroutine analysis_object_clear
 
 @ %def analysis_object_clear
 @
 \subsubsection{Fill with data}
 Record data.  The effect depends on the type of analysis object.
 <<Analysis: procedures>>=
   subroutine analysis_object_record_data (obj, &
        x, y, yerr, xerr, weight, excess, success)
     type(analysis_object_t), intent(inout) :: obj
     real(default), intent(in) :: x
     real(default), intent(in), optional :: y, yerr, xerr, weight, excess
     logical, intent(out), optional :: success
     select case (obj%type)
     case (AN_OBSERVABLE)
        if (present (weight)) then
           call observable_record_value_weighted (obj%obs, x, weight, success)
        else
           call observable_record_value_unweighted (obj%obs, x, success)
        end if
     case (AN_HISTOGRAM)
        if (present (weight)) then
           call histogram_record_value_weighted (obj%h, x, weight, success)
        else
           call histogram_record_value_unweighted (obj%h, x, excess, success)
        end if
     case (AN_PLOT)
        if (present (y)) then
           call plot_record_value (obj%p, x, y, yerr, xerr, success)
        else
           if (present (success))  success = .false.
        end if
     case default
        if (present (success))  success = .false.
     end select
   end subroutine analysis_object_record_data
 
 @ %def analysis_object_record_data
 @ Explicitly set the pointer to the next object in the list.
 <<Analysis: procedures>>=
   subroutine analysis_object_set_next_ptr (obj, next)
     type(analysis_object_t), intent(inout) :: obj
     type(analysis_object_t), pointer :: next
     obj%next => next
   end subroutine analysis_object_set_next_ptr
 
 @ %def analysis_object_set_next_ptr
 @
 \subsubsection{Access contents}
 Return a pointer to the next object in the list.
 <<Analysis: procedures>>=
   function analysis_object_get_next_ptr (obj) result (next)
     type(analysis_object_t), pointer :: next
     type(analysis_object_t), intent(in) :: obj
     next => obj%next
   end function analysis_object_get_next_ptr
 
 @ %def analysis_object_get_next_ptr
 @ Return data as appropriate for the object type.
 <<Analysis: procedures>>=
   function analysis_object_get_n_elements (obj) result (n)
     integer :: n
     type(analysis_object_t), intent(in) :: obj
     select case (obj%type)
     case (AN_HISTOGRAM)
        n = 1
     case (AN_PLOT)
        n = 1
     case (AN_GRAPH)
        n = graph_get_n_elements (obj%g)
     case default
        n = 0
     end select
   end function analysis_object_get_n_elements
 
   function analysis_object_get_n_entries (obj, within_bounds) result (n)
     integer :: n
     type(analysis_object_t), intent(in) :: obj
     logical, intent(in), optional :: within_bounds
     logical :: wb
     select case (obj%type)
     case (AN_OBSERVABLE)
        n = observable_get_n_entries (obj%obs)
     case (AN_HISTOGRAM)
        wb = .false.;  if (present (within_bounds)) wb = within_bounds
        if (wb) then
           n = histogram_get_n_entries_within_bounds (obj%h)
        else
           n = histogram_get_n_entries (obj%h)
        end if
     case (AN_PLOT)
        n = plot_get_n_entries (obj%p)
     case default
        n = 0
     end select
   end function analysis_object_get_n_entries
 
   function analysis_object_get_average (obj, within_bounds) result (avg)
     real(default) :: avg
     type(analysis_object_t), intent(in) :: obj
     logical, intent(in), optional :: within_bounds
     logical :: wb
     select case (obj%type)
     case (AN_OBSERVABLE)
        avg = observable_get_average (obj%obs)
     case (AN_HISTOGRAM)
        wb = .false.;  if (present (within_bounds)) wb = within_bounds
        if (wb) then
           avg = histogram_get_average_within_bounds (obj%h)
        else
           avg = histogram_get_average (obj%h)
        end if
     case default
        avg = 0
     end select
   end function analysis_object_get_average
 
   function analysis_object_get_error (obj, within_bounds) result (err)
     real(default) :: err
     type(analysis_object_t), intent(in) :: obj
     logical, intent(in), optional :: within_bounds
     logical :: wb
     select case (obj%type)
     case (AN_OBSERVABLE)
        err = observable_get_error (obj%obs)
     case (AN_HISTOGRAM)
        wb = .false.;  if (present (within_bounds)) wb = within_bounds
        if (wb) then
           err = histogram_get_error_within_bounds (obj%h)
        else
           err = histogram_get_error (obj%h)
        end if
     case default
        err = 0
     end select
   end function analysis_object_get_error
 
 @ %def analysis_object_get_n_elements
 @ %def analysis_object_get_n_entries
 @ %def analysis_object_get_average
 @ %def analysis_object_get_error
 @ Return pointers to the actual contents:
 <<Analysis: procedures>>=
   function analysis_object_get_observable_ptr (obj) result (obs)
     type(observable_t), pointer :: obs
     type(analysis_object_t), intent(in) :: obj
     select case (obj%type)
     case (AN_OBSERVABLE);  obs => obj%obs
     case default;          obs => null ()
     end select
   end function analysis_object_get_observable_ptr
 
   function analysis_object_get_histogram_ptr (obj) result (h)
     type(histogram_t), pointer :: h
     type(analysis_object_t), intent(in) :: obj
     select case (obj%type)
     case (AN_HISTOGRAM);  h => obj%h
     case default;         h => null ()
     end select
   end function analysis_object_get_histogram_ptr
 
   function analysis_object_get_plot_ptr (obj) result (plot)
     type(plot_t), pointer :: plot
     type(analysis_object_t), intent(in) :: obj
     select case (obj%type)
     case (AN_PLOT);  plot => obj%p
     case default;    plot => null ()
     end select
   end function analysis_object_get_plot_ptr
 
   function analysis_object_get_graph_ptr (obj) result (g)
     type(graph_t), pointer :: g
     type(analysis_object_t), intent(in) :: obj
     select case (obj%type)
     case (AN_GRAPH);  g => obj%g
     case default;     g => null ()
     end select
   end function analysis_object_get_graph_ptr
 
 @ %def analysis_object_get_observable_ptr
 @ %def analysis_object_get_histogram_ptr
 @ %def analysis_object_get_plot_ptr
 @ %def analysis_object_get_graph_ptr
 @ Return true if the object has a graphical representation:
 <<Analysis: procedures>>=
   function analysis_object_has_plot (obj) result (flag)
     logical :: flag
     type(analysis_object_t), intent(in) :: obj
     select case (obj%type)
     case (AN_HISTOGRAM);  flag = .true.
     case (AN_PLOT);       flag = .true.
     case (AN_GRAPH);      flag = .true.
     case default;         flag = .false.
     end select
   end function analysis_object_has_plot
 
 @ %def analysis_object_has_plot
 @
 \subsubsection{Output}
 <<Analysis: procedures>>=
   subroutine analysis_object_write (obj, unit, verbose)
     type(analysis_object_t), intent(in) :: obj
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose
     logical :: verb
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     verb = .false.;  if (present (verbose))  verb = verbose
     write (u, "(A)")  repeat ("#", 79)
     select case (obj%type)
     case (AN_OBSERVABLE)
        write (u, "(A)", advance="no")  "# Observable:"
     case (AN_HISTOGRAM)
        write (u, "(A)", advance="no")  "# Histogram: "
     case (AN_PLOT)
        write (u, "(A)", advance="no")  "# Plot: "
     case (AN_GRAPH)
        write (u, "(A)", advance="no")  "# Graph: "
     case default
        write (u, "(A)") "# [undefined analysis object]"
        return
     end select
     write (u, "(1x,A)")  char (obj%id)
     select case (obj%type)
     case (AN_OBSERVABLE)
        call observable_write (obj%obs, unit)
     case (AN_HISTOGRAM)
        if (verb) then
           call graph_options_write (obj%h%graph_options, unit)
           write (u, *)
           call drawing_options_write (obj%h%drawing_options, unit)
           write (u, *)
        end if
        call histogram_write (obj%h, unit)
     case (AN_PLOT)
        if (verb) then
           call graph_options_write (obj%p%graph_options, unit)
           write (u, *)
           call drawing_options_write (obj%p%drawing_options, unit)
           write (u, *)
        end if
        call plot_write (obj%p, unit)
     case (AN_GRAPH)
        call graph_write (obj%g, unit)
     end select
   end subroutine analysis_object_write
 
 @ %def analysis_object_write
 @ Write the object part of the \LaTeX\ driver file.
 <<Analysis: procedures>>=
   subroutine analysis_object_write_driver (obj, filename, unit)
     type(analysis_object_t), intent(in) :: obj
     type(string_t), intent(in) :: filename
     integer, intent(in), optional :: unit
     select case (obj%type)
     case (AN_OBSERVABLE)
        call observable_write_driver (obj%obs, unit)
     case (AN_HISTOGRAM)
        call histogram_write_gml_driver (obj%h, filename, unit)
     case (AN_PLOT)
        call plot_write_gml_driver (obj%p, filename, unit)
     case (AN_GRAPH)
        call graph_write_gml_driver (obj%g, filename, unit)
     end select
   end subroutine analysis_object_write_driver
 
 @ %def analysis_object_write_driver
 @ Return a data header for external formats, in ifile form.
 <<Analysis: procedures>>=
   subroutine analysis_object_get_header (obj, header, comment)
     type(analysis_object_t), intent(in) :: obj
     type(ifile_t), intent(inout) :: header
     type(string_t), intent(in), optional :: comment
     select case (obj%type)
     case (AN_HISTOGRAM)
        call histogram_get_header (obj%h, header, comment)
     case (AN_PLOT)
        call plot_get_header (obj%p, header, comment)
     end select
   end subroutine analysis_object_get_header
 
 @ %def analysis_object_get_header
 @
 \subsection{Analysis object iterator}
 Analysis objects are containers which have iterable data structures:
 histograms/bins and plots/points.  If they are to be treated on a common
 basis, it is useful to have an iterator which hides the implementation
 details.
 
 The iterator is used only for elementary analysis objects that contain plot
 data: histograms or plots.  It is invalid for meta-objects (graphs) and
 non-graphical objects (observables).
 <<Analysis: public>>=
   public :: analysis_iterator_t
 <<Analysis: types>>=
   type :: analysis_iterator_t
     private
     integer :: type = AN_UNDEFINED
     type(analysis_object_t), pointer :: object => null ()
     integer :: index = 1
     type(point_t), pointer :: point => null ()
   end type
 
 @ %def analysis_iterator_t
 @ The initializer places the iterator at the beginning of the analysis object.
 <<Analysis: procedures>>=
   subroutine analysis_iterator_init (iterator, object)
     type(analysis_iterator_t), intent(out) :: iterator
     type(analysis_object_t), intent(in), target :: object
     iterator%object => object
     if (associated (iterator%object)) then
        iterator%type = iterator%object%type
        select case (iterator%type)
        case (AN_PLOT)
           iterator%point => iterator%object%p%first
        end select
     end if
   end subroutine analysis_iterator_init
 
 @ %def analysis_iterator_init
 @ The iterator is valid as long as it points to an existing entry.  An
 iterator for a data object without array data (observable) is always invalid.
 <<Analysis: public>>=
   public :: analysis_iterator_is_valid
 <<Analysis: procedures>>=
   function analysis_iterator_is_valid (iterator) result (valid)
     logical :: valid
     type(analysis_iterator_t), intent(in) :: iterator
     if (associated (iterator%object)) then
        select case (iterator%type)
        case (AN_HISTOGRAM)
           valid = iterator%index <= histogram_get_n_bins (iterator%object%h)
        case (AN_PLOT)
           valid = associated (iterator%point)
        case default
           valid = .false.
        end select
     else
        valid = .false.
     end if
   end function analysis_iterator_is_valid
 
 @ %def analysis_iterator_is_valid
 @ Advance the iterator.
 <<Analysis: public>>=
   public :: analysis_iterator_advance
 <<Analysis: procedures>>=
   subroutine analysis_iterator_advance (iterator)
     type(analysis_iterator_t), intent(inout) :: iterator
     if (associated (iterator%object)) then
        select case (iterator%type)
        case (AN_PLOT)
           iterator%point => iterator%point%next
        end select
        iterator%index = iterator%index + 1
     end if
   end subroutine analysis_iterator_advance
 
 @ %def analysis_iterator_advance
 @ Retrieve the object type:
 <<Analysis: public>>=
   public :: analysis_iterator_get_type
 <<Analysis: procedures>>=
   function analysis_iterator_get_type (iterator) result (type)
     integer :: type
     type(analysis_iterator_t), intent(in) :: iterator
     type = iterator%type
   end function analysis_iterator_get_type
 
 @ %def analysis_iterator_get_type
 @ Use the iterator to retrieve data.  We implement a common routine which
 takes the data descriptors as optional arguments.  Data which do not occur in
 the selected type trigger to an error condition.
 
 The iterator must point to a valid entry.
 <<Analysis: public>>=
   public :: analysis_iterator_get_data
 <<Analysis: procedures>>=
   subroutine analysis_iterator_get_data (iterator, &
        x, y, yerr, xerr, width, excess, index, n_total)
     type(analysis_iterator_t), intent(in) :: iterator
     real(default), intent(out), optional :: x, y, yerr, xerr, width, excess
     integer, intent(out), optional :: index, n_total
     select case (iterator%type)
     case (AN_HISTOGRAM)
        if (present (x)) &
             x = bin_get_midpoint (iterator%object%h%bin(iterator%index))
        if (present (y)) &
             y = bin_get_sum (iterator%object%h%bin(iterator%index))
        if (present (yerr)) &
             yerr = bin_get_error (iterator%object%h%bin(iterator%index))
        if (present (xerr)) &
             call invalid ("histogram", "xerr")
        if (present (width)) &
             width = bin_get_width (iterator%object%h%bin(iterator%index))
        if (present (excess)) &
             excess = bin_get_excess (iterator%object%h%bin(iterator%index))
        if (present (index)) &
             index = iterator%index
        if (present (n_total)) &
             n_total = histogram_get_n_bins (iterator%object%h)
     case (AN_PLOT)
        if (present (x)) &
             x = point_get_x (iterator%point)
        if (present (y)) &
             y = point_get_y (iterator%point)
        if (present (yerr)) &
             yerr = point_get_yerr (iterator%point)
        if (present (xerr)) &
             xerr = point_get_xerr (iterator%point)
        if (present (width)) &
             call invalid ("plot", "width")
        if (present (excess)) &
             call invalid ("plot", "excess")
        if (present (index)) &
             index = iterator%index
        if (present (n_total)) &
             n_total = plot_get_n_entries (iterator%object%p)
     case default
        call msg_bug ("analysis_iterator_get_data: called " &
             // "for unsupported analysis object type")
     end select
   contains
     subroutine invalid (typestr, objstr)
       character(*), intent(in) :: typestr, objstr
       call msg_bug ("analysis_iterator_get_data: attempt to get '" &
            // objstr // "' for type '" // typestr // "'")
     end subroutine invalid
   end subroutine analysis_iterator_get_data
 
 @ %def analysis_iterator_get_data
 @
 \subsection{Analysis store}
 This data structure holds all observables, histograms and such that
 are currently active.  We have one global store; individual items are
 identified by their ID strings and types.
 <<Analysis: variables>>=
   type(analysis_store_t), save :: analysis_store
 
 @ %def analysis_store
 <<Analysis: types>>=
   type :: analysis_store_t
      private
      type(analysis_object_t), pointer :: first => null ()
      type(analysis_object_t), pointer :: last => null ()
   end type analysis_store_t
 
 @ %def analysis_store_t
 @ Delete the analysis store
 <<Analysis: public>>=
   public :: analysis_final
 <<Analysis: procedures>>=
   subroutine analysis_final ()
     type(analysis_object_t), pointer :: current
     do while (associated (analysis_store%first))
        current => analysis_store%first
        analysis_store%first => current%next
        call analysis_object_final (current)
     end do
     analysis_store%last => null ()
   end subroutine analysis_final
 
 @ %def analysis_final
 @ Append a new analysis object
 <<Analysis: procedures>>=
   subroutine analysis_store_append_object (id, type)
     type(string_t), intent(in) :: id
     integer, intent(in) :: type
     type(analysis_object_t), pointer :: obj
     allocate (obj)
     call analysis_object_init (obj, id, type)
     if (associated (analysis_store%last)) then
        analysis_store%last%next => obj
     else
        analysis_store%first => obj
     end if
     analysis_store%last => obj
   end subroutine analysis_store_append_object
 
 @ %def analysis_store_append_object
 @ Return a pointer to the analysis object with given ID.
 <<Analysis: procedures>>=
   function analysis_store_get_object_ptr (id) result (obj)
     type(string_t), intent(in) :: id
     type(analysis_object_t), pointer :: obj
     obj => analysis_store%first
     do while (associated (obj))
        if (obj%id == id)  return
        obj => obj%next
     end do
   end function analysis_store_get_object_ptr
 
 @ %def analysis_store_get_object_ptr
 @ Initialize an analysis object: either reset it if present, or append
 a new entry.
 <<Analysis: procedures>>=
   subroutine analysis_store_init_object (id, type, obj)
     type(string_t), intent(in) :: id
     integer, intent(in) :: type
     type(analysis_object_t), pointer :: obj, next
     obj => analysis_store_get_object_ptr (id)
     if (associated (obj)) then
        next => analysis_object_get_next_ptr (obj)
        call analysis_object_final (obj)
        call analysis_object_init (obj, id, type)
        call analysis_object_set_next_ptr (obj, next)
     else
        call analysis_store_append_object (id, type)
        obj => analysis_store%last
     end if
   end subroutine analysis_store_init_object
 
 @ %def analysis_store_init_object
 @ Get the type of a analysis object
 <<Analysis: public>>=
   public :: analysis_store_get_object_type
 <<Analysis: procedures>>=
   function analysis_store_get_object_type (id) result (type)
     type(string_t), intent(in) :: id
     integer :: type
     type(analysis_object_t), pointer :: object
     object => analysis_store_get_object_ptr (id)
     if (associated (object)) then
        type = object%type
     else
        type = AN_UNDEFINED
     end if
   end function analysis_store_get_object_type
 
 @ %def analysis_store_get_object_type
 @ Return the number of objects in the store.
 <<Analysis: procedures>>=
   function analysis_store_get_n_objects () result (n)
     integer :: n
     type(analysis_object_t), pointer :: current
     n = 0
     current => analysis_store%first
     do while (associated (current))
        n = n + 1
        current => current%next
     end do
   end function analysis_store_get_n_objects
 
 @ %def analysis_store_get_n_objects
 @ Allocate an array and fill it with all existing IDs.
 <<Analysis: public>>=
   public :: analysis_store_get_ids
 <<Analysis: procedures>>=
   subroutine analysis_store_get_ids (id)
     type(string_t), dimension(:), allocatable, intent(out) :: id
     type(analysis_object_t), pointer :: current
     integer :: i
     allocate (id (analysis_store_get_n_objects()))
     i = 0
     current => analysis_store%first
     do while (associated (current))
        i = i + 1
        id(i) = current%id
        current => current%next
     end do
   end subroutine analysis_store_get_ids
 
 @ %def analysis_store_get_ids
 @
 \subsection{\LaTeX\ driver file}
 Write a driver file for all objects in the store.
 <<Analysis: procedures>>=
   subroutine analysis_store_write_driver_all (filename_data, unit)
     type(string_t), intent(in) :: filename_data
     integer, intent(in), optional :: unit
     type(analysis_object_t), pointer :: obj
     call analysis_store_write_driver_header (unit)
     obj => analysis_store%first
     do while (associated (obj))
        call analysis_object_write_driver (obj, filename_data, unit)
        obj => obj%next
     end do
     call analysis_store_write_driver_footer (unit)
   end subroutine analysis_store_write_driver_all
 
 @ %def analysis_store_write_driver_all
 @
 Write a driver file for an array of objects.
 <<Analysis: procedures>>=
   subroutine analysis_store_write_driver_obj (filename_data, id, unit)
     type(string_t), intent(in) :: filename_data
     type(string_t), dimension(:), intent(in) :: id
     integer, intent(in), optional :: unit
     type(analysis_object_t), pointer :: obj
     integer :: i
     call analysis_store_write_driver_header (unit)
     do i = 1, size (id)
        obj => analysis_store_get_object_ptr (id(i))
        if (associated (obj))  &
             call analysis_object_write_driver (obj, filename_data, unit)
     end do
     call analysis_store_write_driver_footer (unit)
   end subroutine analysis_store_write_driver_obj
 
 @ %def analysis_store_write_driver_obj
 @ The beginning of the driver file.
 <<Analysis: procedures>>=
   subroutine analysis_store_write_driver_header (unit)
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     write (u, '(A)') "\documentclass[12pt]{article}"
     write (u, *)
     write (u, '(A)') "\usepackage{gamelan}"
     write (u, '(A)') "\usepackage{amsmath}"
     write (u, '(A)') "\usepackage{ifpdf}"
     write (u, '(A)') "\ifpdf"
     write (u, '(A)') "   \DeclareGraphicsRule{*}{mps}{*}{}"
     write (u, '(A)') "\else"
     write (u, '(A)') "   \DeclareGraphicsRule{*}{eps}{*}{}"
     write (u, '(A)') "\fi"
     write (u, *)
     write (u, '(A)') "\begin{document}"
     write (u, '(A)') "\begin{gmlfile}"
     write (u, *)
     write (u, '(A)') "\begin{gmlcode}"
     write (u, '(A)') "  color col.default, col.excess;"
     write (u, '(A)') "  col.default = 0.9white;"
     write (u, '(A)') "  col.excess  = red;"
     write (u, '(A)') "  boolean show_excess;"
     !!! Future excess options for plots
     ! if (mcs(1)%plot_excess .and. mcs(1)%unweighted) then
     !    write (u, '(A)') "  show_excess = true;"
     ! else
     write (u, '(A)') "  show_excess = false;"
     ! end if
     write (u, '(A)') "\end{gmlcode}"
     write (u, *)
   end subroutine analysis_store_write_driver_header
 
 @ %def analysis_store_write_driver_header
 @ The end of the driver file.
 <<Analysis: procedures>>=
   subroutine analysis_store_write_driver_footer (unit)
     integer, intent(in), optional :: unit
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     write(u, *)
     write(u, '(A)') "\end{gmlfile}"
     write(u, '(A)') "\end{document}"
   end subroutine analysis_store_write_driver_footer
 
 @ %def analysis_store_write_driver_footer
 @
 \subsection{API}
 \subsubsection{Creating new objects}
 The specific versions below:
 <<Analysis: public>>=
   public :: analysis_init_observable
 <<Analysis: procedures>>=
   subroutine analysis_init_observable (id, obs_label, obs_unit, graph_options)
     type(string_t), intent(in) :: id
     type(string_t), intent(in), optional :: obs_label, obs_unit
     type(graph_options_t), intent(in), optional :: graph_options
     type(analysis_object_t), pointer :: obj
     type(observable_t), pointer :: obs
     call analysis_store_init_object (id, AN_OBSERVABLE, obj)
     obs => analysis_object_get_observable_ptr (obj)
     call observable_init (obs, obs_label, obs_unit, graph_options)
   end subroutine analysis_init_observable
 
 @ %def analysis_init_observable
 <<Analysis: public>>=
   public :: analysis_init_histogram
 <<Analysis: interfaces>>=
   interface analysis_init_histogram
      module procedure analysis_init_histogram_n_bins
      module procedure analysis_init_histogram_bin_width
   end interface
 
 <<Analysis: procedures>>=
   subroutine analysis_init_histogram_n_bins &
        (id, lower_bound, upper_bound, n_bins, normalize_bins, &
         obs_label, obs_unit, graph_options, drawing_options)
     type(string_t), intent(in) :: id
     real(default), intent(in) :: lower_bound, upper_bound
     integer, intent(in) :: n_bins
     logical, intent(in) :: normalize_bins
     type(string_t), intent(in), optional :: obs_label, obs_unit
     type(graph_options_t), intent(in), optional :: graph_options
     type(drawing_options_t), intent(in), optional :: drawing_options
     type(analysis_object_t), pointer :: obj
     type(histogram_t), pointer :: h
     call analysis_store_init_object (id, AN_HISTOGRAM, obj)
     h => analysis_object_get_histogram_ptr (obj)
     call histogram_init (h, id, &
          lower_bound, upper_bound, n_bins, normalize_bins, &
          obs_label, obs_unit, graph_options, drawing_options)
   end subroutine analysis_init_histogram_n_bins
 
   subroutine analysis_init_histogram_bin_width &
        (id, lower_bound, upper_bound, bin_width, normalize_bins, &
         obs_label, obs_unit, graph_options, drawing_options)
     type(string_t), intent(in) :: id
     real(default), intent(in) :: lower_bound, upper_bound, bin_width
     logical, intent(in) :: normalize_bins
     type(string_t), intent(in), optional :: obs_label, obs_unit
     type(graph_options_t), intent(in), optional :: graph_options
     type(drawing_options_t), intent(in), optional :: drawing_options
     type(analysis_object_t), pointer :: obj
     type(histogram_t), pointer :: h
     call analysis_store_init_object (id, AN_HISTOGRAM, obj)
     h => analysis_object_get_histogram_ptr (obj)
     call histogram_init (h, id, &
          lower_bound, upper_bound, bin_width, normalize_bins, &
          obs_label, obs_unit, graph_options, drawing_options)
   end subroutine analysis_init_histogram_bin_width
 
 @ %def analysis_init_histogram_n_bins
 @ %def analysis_init_histogram_bin_width
 <<Analysis: public>>=
   public :: analysis_init_plot
 <<Analysis: procedures>>=
   subroutine analysis_init_plot (id, graph_options, drawing_options)
     type(string_t), intent(in) :: id
     type(graph_options_t), intent(in), optional :: graph_options
     type(drawing_options_t), intent(in), optional :: drawing_options
     type(analysis_object_t), pointer :: obj
     type(plot_t), pointer :: plot
     call analysis_store_init_object (id, AN_PLOT, obj)
     plot => analysis_object_get_plot_ptr (obj)
     call plot_init (plot, id, graph_options, drawing_options)
   end subroutine analysis_init_plot
 
 @ %def analysis_init_plot
 <<Analysis: public>>=
   public :: analysis_init_graph
 <<Analysis: procedures>>=
   subroutine analysis_init_graph (id, n_elements, graph_options)
     type(string_t), intent(in) :: id
     integer, intent(in) :: n_elements
     type(graph_options_t), intent(in), optional :: graph_options
     type(analysis_object_t), pointer :: obj
     type(graph_t), pointer :: graph
     call analysis_store_init_object (id, AN_GRAPH, obj)
     graph => analysis_object_get_graph_ptr (obj)
     call graph_init (graph, id, n_elements, graph_options)
   end subroutine analysis_init_graph
 
 @ %def analysis_init_graph
 @
 \subsubsection{Recording data}
 This procedure resets an object or the whole store to its initial
 state.
 <<Analysis: public>>=
   public :: analysis_clear
 <<Analysis: interfaces>>=
   interface analysis_clear
      module procedure analysis_store_clear_obj
      module procedure analysis_store_clear_all
   end interface
 
 <<Analysis: procedures>>=
   subroutine analysis_store_clear_obj (id)
     type(string_t), intent(in) :: id
     type(analysis_object_t), pointer :: obj
     obj => analysis_store_get_object_ptr (id)
     if (associated (obj)) then
        call analysis_object_clear (obj)
     end if
   end subroutine analysis_store_clear_obj
 
   subroutine analysis_store_clear_all ()
     type(analysis_object_t), pointer :: obj
     obj => analysis_store%first
     do while (associated (obj))
        call analysis_object_clear (obj)
        obj => obj%next
     end do
   end subroutine analysis_store_clear_all
 
 @ %def analysis_clear
 @
 There is one generic recording function whose behavior depends on the
 type of analysis object.
 <<Analysis: public>>=
   public :: analysis_record_data
 <<Analysis: procedures>>=
   subroutine analysis_record_data (id, x, y, yerr, xerr, &
        weight, excess, success, exist)
     type(string_t), intent(in) :: id
     real(default), intent(in) :: x
     real(default), intent(in), optional :: y, yerr, xerr, weight, excess
     logical, intent(out), optional :: success, exist
     type(analysis_object_t), pointer :: obj
     obj => analysis_store_get_object_ptr (id)
     if (associated (obj)) then
        call analysis_object_record_data (obj, x, y, yerr, xerr, &
             weight, excess, success)
        if (present (exist))  exist = .true.
     else
        if (present (success))  success = .false.
        if (present (exist))  exist = .false.
     end if
   end subroutine analysis_record_data
 
 @ %def analysis_record_data
 @
 \subsubsection{Build a graph}
 This routine sets up the array of graph elements by copying the graph elements
 given as input.  The object must exist and already be initialized as a graph.
 <<Analysis: public>>=
   public :: analysis_fill_graph
 <<Analysis: procedures>>=
   subroutine analysis_fill_graph (id, i, id_in, drawing_options)
     type(string_t), intent(in) :: id
     integer, intent(in) :: i
     type(string_t), intent(in) :: id_in
     type(drawing_options_t), intent(in), optional :: drawing_options
     type(analysis_object_t), pointer :: obj
     type(graph_t), pointer :: g
     type(histogram_t), pointer :: h
     type(plot_t), pointer :: p
     obj => analysis_store_get_object_ptr (id)
     g => analysis_object_get_graph_ptr (obj)
     obj => analysis_store_get_object_ptr (id_in)
     if (associated (obj)) then
        select case (obj%type)
        case (AN_HISTOGRAM)
           h => analysis_object_get_histogram_ptr (obj)
           call graph_insert_histogram (g, i, h, drawing_options)
        case (AN_PLOT)
           p => analysis_object_get_plot_ptr (obj)
           call graph_insert_plot (g, i, p, drawing_options)
        case default
           call msg_error ("Graph '" // char (id) // "': Element '" &
                // char (id_in) // "' is neither histogram nor plot.")
        end select
     else
        call msg_error ("Graph '" // char (id) // "': Element '" &
                // char (id_in) // "' is undefined.")
     end if
   end subroutine analysis_fill_graph
 
 @ %def analysis_fill_graph
 @
 \subsubsection{Retrieve generic results}
 Check if a named object exists.
 <<Analysis: public>>=
   public :: analysis_exists
 <<Analysis: procedures>>=
   function analysis_exists (id) result (flag)
     type(string_t), intent(in) :: id
     logical :: flag
     type(analysis_object_t), pointer :: obj
     flag = .true.
     obj => analysis_store%first
     do while (associated (obj))
        if (obj%id == id)  return
        obj => obj%next
     end do
     flag = .false.
   end function analysis_exists
 
 @ %def analysis_exists
 @ The following functions should work for all kinds of analysis object:
 <<Analysis: public>>=
   public :: analysis_get_n_elements
   public :: analysis_get_n_entries
   public :: analysis_get_average
   public :: analysis_get_error
 <<Analysis: procedures>>=
   function analysis_get_n_elements (id) result (n)
     integer :: n
     type(string_t), intent(in) :: id
     type(analysis_object_t), pointer :: obj
     obj => analysis_store_get_object_ptr (id)
     if (associated (obj)) then
        n = analysis_object_get_n_elements (obj)
     else
        n = 0
     end if
   end function analysis_get_n_elements
 
   function analysis_get_n_entries (id, within_bounds) result (n)
     integer :: n
     type(string_t), intent(in) :: id
     logical, intent(in), optional :: within_bounds
     type(analysis_object_t), pointer :: obj
     obj => analysis_store_get_object_ptr (id)
     if (associated (obj)) then
        n = analysis_object_get_n_entries (obj, within_bounds)
     else
        n = 0
     end if
   end function analysis_get_n_entries
 
   function analysis_get_average (id, within_bounds) result (avg)
     real(default) :: avg
     type(string_t), intent(in) :: id
     type(analysis_object_t), pointer :: obj
     logical, intent(in), optional :: within_bounds
     obj => analysis_store_get_object_ptr (id)
     if (associated (obj)) then
        avg = analysis_object_get_average (obj, within_bounds)
     else
        avg = 0
     end if
   end function analysis_get_average
 
   function analysis_get_error (id, within_bounds) result (err)
     real(default) :: err
     type(string_t), intent(in) :: id
     type(analysis_object_t), pointer :: obj
     logical, intent(in), optional :: within_bounds
     obj => analysis_store_get_object_ptr (id)
     if (associated (obj)) then
        err = analysis_object_get_error (obj, within_bounds)
     else
        err = 0
     end if
   end function analysis_get_error
 
 @ %def analysis_get_n_elements
 @ %def analysis_get_n_entries
 @ %def analysis_get_average
 @ %def analysis_get_error
 @ Return true if any analysis object is graphical
 <<Analysis: public>>=
   public :: analysis_has_plots
 <<Analysis: interfaces>>=
   interface analysis_has_plots
      module procedure analysis_has_plots_any
      module procedure analysis_has_plots_obj
   end interface
 
 <<Analysis: procedures>>=
   function analysis_has_plots_any () result (flag)
     logical :: flag
     type(analysis_object_t), pointer :: obj
     flag = .false.
     obj => analysis_store%first
     do while (associated (obj))
        flag = analysis_object_has_plot (obj)
        if (flag)  return
     end do
   end function analysis_has_plots_any
 
   function analysis_has_plots_obj (id) result (flag)
     logical :: flag
     type(string_t), dimension(:), intent(in) :: id
     type(analysis_object_t), pointer :: obj
     integer :: i
     flag = .false.
     do i = 1, size (id)
        obj => analysis_store_get_object_ptr (id(i))
        if (associated (obj)) then
           flag = analysis_object_has_plot (obj)
           if (flag)  return
        end if
     end do
   end function analysis_has_plots_obj
 
 @ %def analysis_has_plots
 @
 \subsubsection{Iterators}
 Initialize an iterator for the given object.  If the object does not exist or
 has wrong type, the iterator will be invalid.
 <<Analysis: public>>=
   public :: analysis_init_iterator
 <<Analysis: procedures>>=
   subroutine analysis_init_iterator (id, iterator)
     type(string_t), intent(in) :: id
     type(analysis_iterator_t), intent(out) :: iterator
     type(analysis_object_t), pointer :: obj
     obj => analysis_store_get_object_ptr (id)
     if (associated (obj))  call analysis_iterator_init (iterator, obj)
   end subroutine analysis_init_iterator
 
 @ %def analysis_init_iterator
 @
 \subsubsection{Output}
 <<Analysis: public>>=
   public :: analysis_write
 <<Analysis: interfaces>>=
   interface analysis_write
      module procedure analysis_write_object
      module procedure analysis_write_all
   end interface
 
 @ %def interface
 <<Analysis: procedures>>=
   subroutine analysis_write_object (id, unit, verbose)
     type(string_t), intent(in) :: id
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose
     type(analysis_object_t), pointer :: obj
     obj => analysis_store_get_object_ptr (id)
     if (associated (obj)) then
        call analysis_object_write (obj, unit, verbose)
     else
        call msg_error ("Analysis object '" // char (id) // "' not found")
     end if
   end subroutine analysis_write_object
 
   subroutine analysis_write_all (unit, verbose)
     integer, intent(in), optional :: unit
     logical, intent(in), optional :: verbose
     type(analysis_object_t), pointer :: obj
     integer :: u
     u = given_output_unit (unit);  if (u < 0)  return
     obj => analysis_store%first
     do while (associated (obj))
        call analysis_object_write (obj, unit, verbose)
        obj => obj%next
     end do
   end subroutine analysis_write_all
 
 @ %def analysis_write_object
 @ %def analysis_write_all
 <<Analysis: public>>=
   public :: analysis_write_driver
 <<Analysis: procedures>>=
   subroutine analysis_write_driver (filename_data, id, unit)
     type(string_t), intent(in) :: filename_data
     type(string_t), dimension(:), intent(in), optional :: id
     integer, intent(in), optional :: unit
     if (present (id)) then
        call analysis_store_write_driver_obj (filename_data, id, unit)
     else
        call analysis_store_write_driver_all (filename_data, unit)
     end if
   end subroutine analysis_write_driver
 
 @ %def analysis_write_driver
 <<Analysis: public>>=
   public :: analysis_compile_tex
 <<Analysis: procedures>>=
   subroutine analysis_compile_tex (file, has_gmlcode, os_data)
     type(string_t), intent(in) :: file
     logical, intent(in) :: has_gmlcode
     type(os_data_t), intent(in) :: os_data
     integer :: status
     if (os_data%event_analysis_ps) then
        call os_system_call ("make compile " // os_data%makeflags // " -f " // &
             char (file) // "_ana.makefile", status)
        if (status /= 0) then
           call msg_error ("Unable to compile analysis output file")
        end if
     else
        call msg_warning ("Skipping results display because " &
             // "latex/mpost/dvips is not available")
     end if
   end subroutine analysis_compile_tex
 
 @ %def analysis_compile_tex
 @ Write header for generic data output to an ifile.
 <<Analysis: public>>=
   public :: analysis_get_header
 <<Analysis: procedures>>=
   subroutine analysis_get_header (id, header, comment)
     type(string_t), intent(in) :: id
     type(ifile_t), intent(inout) :: header
     type(string_t), intent(in), optional :: comment
     type(analysis_object_t), pointer :: object
     object => analysis_store_get_object_ptr (id)
     if (associated (object)) then
        call analysis_object_get_header (object, header, comment)
     end if
   end subroutine analysis_get_header
 
 @ %def analysis_get_header
 @ Write a makefile in order to do the compile steps.
 <<Analysis: public>>=
   public :: analysis_write_makefile
 <<Analysis: procedures>>=
   subroutine analysis_write_makefile (filename, unit, has_gmlcode, os_data)
     type(string_t), intent(in) :: filename
     integer, intent(in) :: unit
     logical, intent(in) :: has_gmlcode
     type(os_data_t), intent(in) :: os_data
     write (unit, "(3A)")  "# WHIZARD: Makefile for analysis '", &
          char (filename), "'"
     write (unit, "(A)")  "# Automatically generated file, do not edit"
     write (unit, "(A)")  ""
     write (unit, "(A)")  "# LaTeX setup"
     write (unit, "(A)")  "LATEX = " // char (os_data%latex)
     write (unit, "(A)")  "MPOST = " // char (os_data%mpost)
     write (unit, "(A)")  "GML = " // char (os_data%gml)
     write (unit, "(A)")  "DVIPS = " // char (os_data%dvips)
     write (unit, "(A)")  "PS2PDF = " // char (os_data%ps2pdf)
     write (unit, "(A)")  'TEX_FLAGS = "$$TEXINPUTS:' // &
          char(os_data%whizard_texpath) // '"'
     write (unit, "(A)")  'MP_FLAGS  = "$$MPINPUTS:' // &
          char(os_data%whizard_texpath) // '"'
     write (unit, "(A)")  ""
     write (unit, "(5A)")  "TEX_SOURCES = ", char (filename), ".tex"
     if (os_data%event_analysis_pdf) then
        write (unit, "(5A)")  "TEX_OBJECTS = ", char (filename), ".pdf"
     else
        write (unit, "(5A)")  "TEX_OBJECTS = ", char (filename), ".ps"
     end if
     if (os_data%event_analysis_ps) then
        if (os_data%event_analysis_pdf) then
           write (unit, "(5A)")  char (filename), ".pdf: ", &
                char (filename), ".tex"
        else
           write (unit, "(5A)")  char (filename), ".ps: ", &
                char (filename), ".tex"
        end if
        write (unit, "(5A)")  TAB, "-TEXINPUTS=$(TEX_FLAGS) $(LATEX) " // &
             char (filename) // ".tex"
        if (has_gmlcode) then
           write (unit, "(5A)")  TAB, "$(GML) " // char (filename)
           write (unit, "(5A)")  TAB, "TEXINPUTS=$(TEX_FLAGS) $(LATEX) " // &
             char (filename) // ".tex"
        end if
        write (unit, "(5A)")  TAB, "$(DVIPS) -o " // char (filename) // ".ps " // &
             char (filename) // ".dvi"
        if (os_data%event_analysis_pdf) then
           write (unit, "(5A)")  TAB, "$(PS2PDF) " // char (filename) // ".ps"
        end if
     end if
     write (unit, "(A)")
     write (unit, "(A)")  "compile: $(TEX_OBJECTS)"
     write (unit, "(A)")  ".PHONY: compile"
     write (unit, "(A)")
     write (unit, "(5A)")  "CLEAN_OBJECTS = ",  char (filename), ".aux"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".log"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".dvi"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".out"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".[1-9]"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".[1-9][0-9]"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".[1-9][0-9][0-9]"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".t[1-9]"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".t[1-9][0-9]"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".t[1-9][0-9][0-9]"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".ltp"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".mp"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".mpx"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".dvi"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".ps"
     write (unit, "(5A)")  "CLEAN_OBJECTS += ", char (filename), ".pdf"
     write (unit, "(A)")
     write (unit, "(A)")  "# Generic cleanup targets"
     write (unit, "(A)")  "clean-objects:"
     write (unit, "(A)")  TAB // "rm -f $(CLEAN_OBJECTS)"
     write (unit, "(A)")  ""
     write (unit, "(A)")  "clean: clean-objects"
     write (unit, "(A)")  ".PHONY: clean"
   end subroutine analysis_write_makefile
 
 @ %def analysis_write_makefile
 @
 \subsection{Unit tests}
 Test module, followed by the corresponding implementation module.
 <<[[analysis_ut.f90]]>>=
 <<File header>>
 
 module analysis_ut
   use unit_tests
   use analysis_uti
 
 <<Standard module head>>
 
 <<Analysis: public test>>
 
 contains
 
 <<Analysis: test driver>>
 
 end module analysis_ut
 @ %def analysis_ut
 @
 <<[[analysis_uti.f90]]>>=
 <<File header>>
 
 module analysis_uti
 
 <<Use kinds>>
 <<Use strings>>
   use format_defs, only: FMT_19
 
   use analysis
 
 <<Standard module head>>
 
 <<Analysis: test declarations>>
 
 contains
 
 <<Analysis: tests>>
 
 end module analysis_uti
 @ %def analysis_ut
 @ API: driver for the unit tests below.
 <<Analysis: public test>>=
   public :: analysis_test
 <<Analysis: test driver>>=
   subroutine analysis_test (u, results)
     integer, intent(in) :: u
     type(test_results_t), intent(inout) :: results
   <<Analysis: execute tests>>
   end subroutine analysis_test
 
 @ %def analysis_test
 <<Analysis: execute tests>>=
   call test (analysis_1, "analysis_1", &
        "check elementary analysis building blocks", &
        u, results)
 <<Analysis: test declarations>>=
   public :: analysis_1
 <<Analysis: tests>>=
   subroutine analysis_1 (u)
     integer, intent(in) :: u
     type(string_t) :: id1, id2, id3, id4
     integer :: i
     id1 = "foo"
     id2 = "bar"
     id3 = "hist"
     id4 = "plot"
 
     write (u, "(A)")  "* Test output: Analysis"
     write (u, "(A)")  "*   Purpose: test the analysis routines"
     write (u, "(A)")
 
     call analysis_init_observable (id1)
     call analysis_init_observable (id2)
     call analysis_init_histogram &
          (id3, 0.5_default, 5.5_default, 1._default, normalize_bins=.false.)
     call analysis_init_plot (id4)
     do i = 1, 3
        write (u, "(A,1x," // FMT_19 // ")")  "data = ", real(i,default)
        call analysis_record_data (id1, real(i,default))
        call analysis_record_data (id2, real(i,default), &
                                         weight=real(i,default))
        call analysis_record_data (id3, real(i,default))
        call analysis_record_data (id4, real(i,default), real(i,default)**2)
     end do
     write (u, "(A,10(1x,I5))") "n_entries = ", &
          analysis_get_n_entries (id1), &
          analysis_get_n_entries (id2), &
          analysis_get_n_entries (id3), &
          analysis_get_n_entries (id3, within_bounds = .true.), &
          analysis_get_n_entries (id4), &
          analysis_get_n_entries (id4, within_bounds = .true.)
     write (u, "(A,10(1x," // FMT_19 // "))")  "average   = ", &
          analysis_get_average (id1), &
          analysis_get_average (id2), &
          analysis_get_average (id3), &
          analysis_get_average (id3, within_bounds = .true.)
     write (u, "(A,10(1x," // FMT_19 // "))")  "error     = ", &
          analysis_get_error (id1), &
          analysis_get_error (id2), &
          analysis_get_error (id3), &
          analysis_get_error (id3, within_bounds = .true.)
 
     write (u, "(A)")
     write (u, "(A)") "* Clear analysis #2"
     write (u, "(A)")
 
     call analysis_clear (id2)
     do i = 4, 6
        print *, "data = ", real(i,default)
        call analysis_record_data (id1, real(i,default))
        call analysis_record_data (id2, real(i,default), &
                                         weight=real(i,default))
        call analysis_record_data (id3, real(i,default))
        call analysis_record_data (id4, real(i,default), real(i,default)**2)
     end do
     write (u, "(A,10(1x,I5))")  "n_entries = ", &
          analysis_get_n_entries (id1), &
          analysis_get_n_entries (id2), &
          analysis_get_n_entries (id3), &
          analysis_get_n_entries (id3, within_bounds = .true.), &
          analysis_get_n_entries (id4), &
          analysis_get_n_entries (id4, within_bounds = .true.)
     write (u, "(A,10(1x," // FMT_19 // "))")  "average   = ", &
          analysis_get_average (id1), &
          analysis_get_average (id2), &
          analysis_get_average (id3), &
          analysis_get_average (id3, within_bounds = .true.)
     write (u, "(A,10(1x," // FMT_19 // "))")  "error     = ", &
          analysis_get_error (id1), &
          analysis_get_error (id2), &
          analysis_get_error (id3), &
          analysis_get_error (id3, within_bounds = .true.)
     write (u, "(A)")
     call analysis_write (u)
 
     write (u, "(A)")
     write (u, "(A)")  "* Cleanup"
 
     call analysis_clear ()
     call analysis_final ()
 
     write (u, "(A)")
     write (u, "(A)")  "* Test output end: analysis_1"
   end subroutine analysis_1
 
 @ %def analysis_1
Index: trunk/share/tests/Makefile.am
===================================================================
--- trunk/share/tests/Makefile.am	(revision 8163)
+++ trunk/share/tests/Makefile.am	(revision 8164)
@@ -1,1328 +1,1330 @@
 ## Makefile.am -- Makefile for WHIZARD tests
 ##
 ## Process this file with automake to produce Makefile.in
 ##
 ########################################################################
 #
 # Copyright (C) 1999-2018 by
 #     Wolfgang Kilian <kilian@physik.uni-siegen.de>
 #     Thorsten Ohl <ohl@physik.uni-wuerzburg.de>
 #     Juergen Reuter <juergen.reuter@desy.de>
 #     with contributions from
 #     cf. main AUTHORS file
 #
 # WHIZARD is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2, or (at your option)
 # any later version.
 #
 # WHIZARD is distributed in the hope that it will be useful, but
 # WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 ########################################################################
 
 EXTRA_DIST = \
     $(TESTSUITE_MACROS) $(TESTSUITES_M4) $(TESTSUITES_SIN) \
     $(TESTSUITE_TOOLS) \
     $(REF_OUTPUT_FILES) \
     cascades2_lexer_1.fds \
     cascades2_1.fds \
     cascades2_2.fds \
     functional_tests/structure_2_inc.sin functional_tests/testproc_3.phs \
     functional_tests/user_cuts.f90 \
     functional_tests/susyhit.in nmssm.slha
 
 TESTSUITE_MACROS = testsuite.m4
 TESTSUITE_TOOLS = \
     check-debug-output.py \
     check-hepmc-weights.py \
     compare-integrals.py \
     compare-histograms.py
 
 REF_OUTPUT_FILES = \
     extra_integration_results.dat \
     $(REF_OUTPUT_FILES_BASE) $(REF_OUTPUT_FILES_DOUBLE) \
     $(REF_OUTPUT_FILES_PREC) $(REF_OUTPUT_FILES_EXT) \
     $(REF_OUTPUT_FILES_QUAD)
 
 REF_OUTPUT_FILES_BASE = \
     unit_tests/ref-output/analysis_1.ref \
     unit_tests/ref-output/pdg_arrays_1.ref \
     unit_tests/ref-output/pdg_arrays_2.ref \
     unit_tests/ref-output/pdg_arrays_3.ref \
     unit_tests/ref-output/pdg_arrays_4.ref \
     unit_tests/ref-output/pdg_arrays_5.ref \
     unit_tests/ref-output/expressions_1.ref \
     unit_tests/ref-output/expressions_2.ref \
     unit_tests/ref-output/expressions_3.ref \
     unit_tests/ref-output/expressions_4.ref \
     unit_tests/ref-output/su_algebra_1.ref \
     unit_tests/ref-output/su_algebra_2.ref \
     unit_tests/ref-output/su_algebra_3.ref \
     unit_tests/ref-output/su_algebra_4.ref \
     unit_tests/ref-output/bloch_vectors_1.ref \
     unit_tests/ref-output/bloch_vectors_2.ref \
     unit_tests/ref-output/bloch_vectors_3.ref \
     unit_tests/ref-output/bloch_vectors_4.ref \
     unit_tests/ref-output/bloch_vectors_5.ref \
     unit_tests/ref-output/bloch_vectors_6.ref \
     unit_tests/ref-output/bloch_vectors_7.ref \
     unit_tests/ref-output/polarization_1.ref \
     unit_tests/ref-output/polarization_2.ref \
     unit_tests/ref-output/beam_1.ref \
     unit_tests/ref-output/beam_2.ref \
     unit_tests/ref-output/beam_3.ref \
     unit_tests/ref-output/md5_1.ref \
     unit_tests/ref-output/cputime_1.ref \
     unit_tests/ref-output/cputime_2.ref \
     unit_tests/ref-output/lexer_1.ref \
     unit_tests/ref-output/parse_1.ref \
     unit_tests/ref-output/color_1.ref \
     unit_tests/ref-output/color_2.ref \
     unit_tests/ref-output/os_interface_1.ref \
     unit_tests/ref-output/evaluator_1.ref \
     unit_tests/ref-output/evaluator_2.ref \
     unit_tests/ref-output/evaluator_3.ref \
     unit_tests/ref-output/evaluator_4.ref \
     unit_tests/ref-output/format_1.ref \
     unit_tests/ref-output/sorting_1.ref \
     unit_tests/ref-output/grids_1.ref \
     unit_tests/ref-output/grids_2.ref \
     unit_tests/ref-output/grids_3.ref \
     unit_tests/ref-output/grids_4.ref \
     unit_tests/ref-output/grids_5.ref \
     unit_tests/ref-output/solver_1.ref \
     unit_tests/ref-output/state_matrix_1.ref \
     unit_tests/ref-output/state_matrix_2.ref \
     unit_tests/ref-output/state_matrix_3.ref \
     unit_tests/ref-output/state_matrix_4.ref \
     unit_tests/ref-output/state_matrix_5.ref \
     unit_tests/ref-output/state_matrix_6.ref \
     unit_tests/ref-output/state_matrix_7.ref \
     unit_tests/ref-output/interaction_1.ref \
     unit_tests/ref-output/xml_1.ref \
     unit_tests/ref-output/xml_2.ref \
     unit_tests/ref-output/xml_3.ref \
     unit_tests/ref-output/xml_4.ref \
     unit_tests/ref-output/sm_qcd_1.ref \
     unit_tests/ref-output/sm_physics_1.ref \
     unit_tests/ref-output/sm_physics_2.ref \
     unit_tests/ref-output/models_1.ref \
     unit_tests/ref-output/models_2.ref \
     unit_tests/ref-output/models_3.ref \
     unit_tests/ref-output/models_4.ref \
     unit_tests/ref-output/models_5.ref \
     unit_tests/ref-output/models_6.ref \
     unit_tests/ref-output/models_7.ref \
     unit_tests/ref-output/models_8.ref \
     unit_tests/ref-output/models_9.ref \
     unit_tests/ref-output/auto_components_1.ref \
     unit_tests/ref-output/auto_components_2.ref \
     unit_tests/ref-output/auto_components_3.ref \
     unit_tests/ref-output/radiation_generator_1.ref \
     unit_tests/ref-output/radiation_generator_2.ref \
     unit_tests/ref-output/radiation_generator_3.ref \
     unit_tests/ref-output/radiation_generator_4.ref \
     unit_tests/ref-output/particles_1.ref \
     unit_tests/ref-output/particles_2.ref \
     unit_tests/ref-output/particles_3.ref \
     unit_tests/ref-output/particles_4.ref \
     unit_tests/ref-output/particles_5.ref \
     unit_tests/ref-output/particles_6.ref \
     unit_tests/ref-output/particles_7.ref \
     unit_tests/ref-output/particles_8.ref \
     unit_tests/ref-output/particles_9.ref \
     unit_tests/ref-output/beam_structures_1.ref \
     unit_tests/ref-output/beam_structures_2.ref \
     unit_tests/ref-output/beam_structures_3.ref \
     unit_tests/ref-output/beam_structures_4.ref \
     unit_tests/ref-output/beam_structures_5.ref \
     unit_tests/ref-output/beam_structures_6.ref \
     unit_tests/ref-output/sf_aux_1.ref \
     unit_tests/ref-output/sf_aux_2.ref \
     unit_tests/ref-output/sf_aux_3.ref \
     unit_tests/ref-output/sf_aux_4.ref \
     unit_tests/ref-output/sf_mappings_1.ref \
     unit_tests/ref-output/sf_mappings_2.ref \
     unit_tests/ref-output/sf_mappings_3.ref \
     unit_tests/ref-output/sf_mappings_4.ref \
     unit_tests/ref-output/sf_mappings_5.ref \
     unit_tests/ref-output/sf_mappings_6.ref \
     unit_tests/ref-output/sf_mappings_7.ref \
     unit_tests/ref-output/sf_mappings_8.ref \
     unit_tests/ref-output/sf_mappings_9.ref \
     unit_tests/ref-output/sf_mappings_10.ref \
     unit_tests/ref-output/sf_mappings_11.ref \
     unit_tests/ref-output/sf_mappings_12.ref \
     unit_tests/ref-output/sf_mappings_13.ref \
     unit_tests/ref-output/sf_mappings_14.ref \
     unit_tests/ref-output/sf_mappings_15.ref \
     unit_tests/ref-output/sf_mappings_16.ref \
     unit_tests/ref-output/sf_base_1.ref \
     unit_tests/ref-output/sf_base_2.ref \
     unit_tests/ref-output/sf_base_3.ref \
     unit_tests/ref-output/sf_base_4.ref \
     unit_tests/ref-output/sf_base_5.ref \
     unit_tests/ref-output/sf_base_6.ref \
     unit_tests/ref-output/sf_base_7.ref \
     unit_tests/ref-output/sf_base_8.ref \
     unit_tests/ref-output/sf_base_9.ref \
     unit_tests/ref-output/sf_base_10.ref \
     unit_tests/ref-output/sf_base_11.ref \
     unit_tests/ref-output/sf_base_12.ref \
     unit_tests/ref-output/sf_base_13.ref \
     unit_tests/ref-output/sf_base_14.ref \
     unit_tests/ref-output/sf_pdf_builtin_1.ref \
     unit_tests/ref-output/sf_pdf_builtin_2.ref \
     unit_tests/ref-output/sf_pdf_builtin_3.ref \
     unit_tests/ref-output/sf_lhapdf5_1.ref \
     unit_tests/ref-output/sf_lhapdf5_2.ref \
     unit_tests/ref-output/sf_lhapdf5_3.ref \
     unit_tests/ref-output/sf_lhapdf6_1.ref \
     unit_tests/ref-output/sf_lhapdf6_2.ref \
     unit_tests/ref-output/sf_lhapdf6_3.ref \
     unit_tests/ref-output/sf_isr_1.ref \
     unit_tests/ref-output/sf_isr_2.ref \
     unit_tests/ref-output/sf_isr_3.ref \
     unit_tests/ref-output/sf_isr_4.ref \
     unit_tests/ref-output/sf_isr_5.ref \
     unit_tests/ref-output/sf_epa_1.ref \
     unit_tests/ref-output/sf_epa_2.ref \
     unit_tests/ref-output/sf_epa_3.ref \
     unit_tests/ref-output/sf_epa_4.ref \
     unit_tests/ref-output/sf_epa_5.ref \
     unit_tests/ref-output/sf_ewa_1.ref \
     unit_tests/ref-output/sf_ewa_2.ref \
     unit_tests/ref-output/sf_ewa_3.ref \
     unit_tests/ref-output/sf_ewa_4.ref \
     unit_tests/ref-output/sf_ewa_5.ref \
     unit_tests/ref-output/sf_circe1_1.ref \
     unit_tests/ref-output/sf_circe1_2.ref \
     unit_tests/ref-output/sf_circe1_3.ref \
     unit_tests/ref-output/sf_circe2_1.ref \
     unit_tests/ref-output/sf_circe2_2.ref \
     unit_tests/ref-output/sf_circe2_3.ref \
     unit_tests/ref-output/sf_gaussian_1.ref \
     unit_tests/ref-output/sf_gaussian_2.ref \
     unit_tests/ref-output/sf_beam_events_1.ref \
     unit_tests/ref-output/sf_beam_events_2.ref \
     unit_tests/ref-output/sf_beam_events_3.ref \
     unit_tests/ref-output/sf_escan_1.ref \
     unit_tests/ref-output/sf_escan_2.ref \
     unit_tests/ref-output/phs_base_1.ref \
     unit_tests/ref-output/phs_base_2.ref \
     unit_tests/ref-output/phs_base_3.ref \
     unit_tests/ref-output/phs_base_4.ref \
     unit_tests/ref-output/phs_base_5.ref \
     unit_tests/ref-output/phs_none_1.ref \
     unit_tests/ref-output/phs_single_1.ref \
     unit_tests/ref-output/phs_single_2.ref \
     unit_tests/ref-output/phs_single_3.ref \
     unit_tests/ref-output/phs_single_4.ref \
     unit_tests/ref-output/resonances_1.ref \
     unit_tests/ref-output/resonances_2.ref \
     unit_tests/ref-output/resonances_3.ref \
     unit_tests/ref-output/resonances_4.ref \
     unit_tests/ref-output/resonances_5.ref \
     unit_tests/ref-output/resonances_6.ref \
     unit_tests/ref-output/resonances_7.ref \
     unit_tests/ref-output/phs_tree_1.ref \
     unit_tests/ref-output/phs_tree_2.ref \
     unit_tests/ref-output/phs_forest_1.ref \
     unit_tests/ref-output/phs_forest_2.ref \
     unit_tests/ref-output/phs_wood_1.ref \
     unit_tests/ref-output/phs_wood_2.ref \
     unit_tests/ref-output/phs_wood_3.ref \
     unit_tests/ref-output/phs_wood_4.ref \
     unit_tests/ref-output/phs_wood_5.ref \
     unit_tests/ref-output/phs_wood_6.ref \
     unit_tests/ref-output/phs_wood_vis_1.ref \
     unit_tests/ref-output/phs_fks_generator_1.ref \
     unit_tests/ref-output/phs_fks_generator_2.ref \
     unit_tests/ref-output/phs_fks_generator_3.ref \
     unit_tests/ref-output/phs_fks_generator_4.ref \
     unit_tests/ref-output/phs_fks_generator_5.ref \
     unit_tests/ref-output/phs_fks_generator_6.ref \
     unit_tests/ref-output/phs_fks_generator_7.ref \
     unit_tests/ref-output/fks_regions_1.ref \
     unit_tests/ref-output/fks_regions_2.ref \
     unit_tests/ref-output/fks_regions_3.ref \
     unit_tests/ref-output/fks_regions_4.ref \
     unit_tests/ref-output/fks_regions_5.ref \
     unit_tests/ref-output/fks_regions_6.ref \
     unit_tests/ref-output/fks_regions_7.ref \
     unit_tests/ref-output/fks_regions_8.ref \
     unit_tests/ref-output/real_subtraction_1.ref \
     unit_tests/ref-output/prc_recola_1.ref \
     unit_tests/ref-output/prc_recola_2.ref \
     unit_tests/ref-output/rng_base_1.ref \
     unit_tests/ref-output/rng_base_2.ref \
     unit_tests/ref-output/rng_tao_1.ref \
     unit_tests/ref-output/rng_tao_2.ref \
     unit_tests/ref-output/rng_stream_1.ref \
     unit_tests/ref-output/rng_stream_2.ref \
     unit_tests/ref-output/rng_stream_3.ref \
     unit_tests/ref-output/selectors_1.ref \
     unit_tests/ref-output/selectors_2.ref \
     unit_tests/ref-output/vegas_1.ref \
     unit_tests/ref-output/vegas_2.ref \
     unit_tests/ref-output/vegas_3.ref \
     unit_tests/ref-output/vegas_4.ref \
     unit_tests/ref-output/vegas_5.ref \
     unit_tests/ref-output/vegas_6.ref \
     unit_tests/ref-output/vamp2_1.ref \
     unit_tests/ref-output/vamp2_2.ref \
     unit_tests/ref-output/vamp2_3.ref \
     unit_tests/ref-output/vamp2_4.ref \
     unit_tests/ref-output/vamp2_5.ref \
     unit_tests/ref-output/mci_base_1.ref \
     unit_tests/ref-output/mci_base_2.ref \
     unit_tests/ref-output/mci_base_3.ref \
     unit_tests/ref-output/mci_base_4.ref \
     unit_tests/ref-output/mci_base_5.ref \
     unit_tests/ref-output/mci_base_6.ref \
     unit_tests/ref-output/mci_base_7.ref \
     unit_tests/ref-output/mci_base_8.ref \
     unit_tests/ref-output/mci_none_1.ref \
     unit_tests/ref-output/mci_midpoint_1.ref \
     unit_tests/ref-output/mci_midpoint_2.ref \
     unit_tests/ref-output/mci_midpoint_3.ref \
     unit_tests/ref-output/mci_midpoint_4.ref \
     unit_tests/ref-output/mci_midpoint_5.ref \
     unit_tests/ref-output/mci_midpoint_6.ref \
     unit_tests/ref-output/mci_midpoint_7.ref \
     unit_tests/ref-output/mci_vamp_1.ref \
     unit_tests/ref-output/mci_vamp_2.ref \
     unit_tests/ref-output/mci_vamp_3.ref \
     unit_tests/ref-output/mci_vamp_4.ref \
     unit_tests/ref-output/mci_vamp_5.ref \
     unit_tests/ref-output/mci_vamp_6.ref \
     unit_tests/ref-output/mci_vamp_7.ref \
     unit_tests/ref-output/mci_vamp_8.ref \
     unit_tests/ref-output/mci_vamp_9.ref \
     unit_tests/ref-output/mci_vamp_10.ref \
     unit_tests/ref-output/mci_vamp_11.ref \
     unit_tests/ref-output/mci_vamp_12.ref \
     unit_tests/ref-output/mci_vamp_13.ref \
     unit_tests/ref-output/mci_vamp_14.ref \
     unit_tests/ref-output/mci_vamp_15.ref \
     unit_tests/ref-output/mci_vamp_16.ref \
     unit_tests/ref-output/mci_vamp2_1.ref \
     unit_tests/ref-output/mci_vamp2_2.ref \
     unit_tests/ref-output/mci_vamp2_3.ref \
     unit_tests/ref-output/integration_results_1.ref \
     unit_tests/ref-output/integration_results_2.ref \
     unit_tests/ref-output/integration_results_3.ref \
     unit_tests/ref-output/integration_results_4.ref \
     unit_tests/ref-output/integration_results_5.ref \
     unit_tests/ref-output/prclib_interfaces_1.ref \
     unit_tests/ref-output/prclib_interfaces_2.ref \
     unit_tests/ref-output/prclib_interfaces_3.ref \
     unit_tests/ref-output/prclib_interfaces_4.ref \
     unit_tests/ref-output/prclib_interfaces_5.ref \
     unit_tests/ref-output/prclib_interfaces_6.ref \
     unit_tests/ref-output/prclib_interfaces_7.ref \
     unit_tests/ref-output/particle_specifiers_1.ref \
     unit_tests/ref-output/particle_specifiers_2.ref \
     unit_tests/ref-output/process_libraries_1.ref \
     unit_tests/ref-output/process_libraries_2.ref \
     unit_tests/ref-output/process_libraries_3.ref \
     unit_tests/ref-output/process_libraries_4.ref \
     unit_tests/ref-output/process_libraries_5.ref \
     unit_tests/ref-output/process_libraries_6.ref \
     unit_tests/ref-output/process_libraries_7.ref \
     unit_tests/ref-output/process_libraries_8.ref \
     unit_tests/ref-output/prclib_stacks_1.ref \
     unit_tests/ref-output/prclib_stacks_2.ref \
     unit_tests/ref-output/slha_1.ref \
     unit_tests/ref-output/slha_2.ref \
     unit_tests/ref-output/prc_test_1.ref \
     unit_tests/ref-output/prc_test_2.ref \
     unit_tests/ref-output/prc_test_3.ref \
     unit_tests/ref-output/prc_test_4.ref \
     unit_tests/ref-output/prc_template_me_1.ref \
     unit_tests/ref-output/prc_template_me_2.ref \
     unit_tests/ref-output/prc_omega_1.ref \
     unit_tests/ref-output/prc_omega_2.ref \
     unit_tests/ref-output/prc_omega_3.ref \
     unit_tests/ref-output/prc_omega_4.ref \
     unit_tests/ref-output/prc_omega_5.ref \
     unit_tests/ref-output/prc_omega_6.ref \
     unit_tests/ref-output/prc_omega_diags_1.ref \
     unit_tests/ref-output/parton_states_1.ref \
     unit_tests/ref-output/subevt_expr_1.ref \
     unit_tests/ref-output/subevt_expr_2.ref \
     unit_tests/ref-output/processes_1.ref \
     unit_tests/ref-output/processes_2.ref \
     unit_tests/ref-output/processes_3.ref \
     unit_tests/ref-output/processes_4.ref \
     unit_tests/ref-output/processes_5.ref \
     unit_tests/ref-output/processes_6.ref \
     unit_tests/ref-output/processes_7.ref \
     unit_tests/ref-output/processes_8.ref \
     unit_tests/ref-output/processes_9.ref \
     unit_tests/ref-output/processes_10.ref \
     unit_tests/ref-output/processes_11.ref \
     unit_tests/ref-output/processes_12.ref \
     unit_tests/ref-output/processes_13.ref \
     unit_tests/ref-output/processes_14.ref \
     unit_tests/ref-output/processes_15.ref \
     unit_tests/ref-output/processes_16.ref \
     unit_tests/ref-output/processes_17.ref \
     unit_tests/ref-output/processes_18.ref \
     unit_tests/ref-output/processes_19.ref \
     unit_tests/ref-output/process_stacks_1.ref \
     unit_tests/ref-output/process_stacks_2.ref \
     unit_tests/ref-output/process_stacks_3.ref \
     unit_tests/ref-output/process_stacks_4.ref \
     unit_tests/ref-output/cascades_1.ref \
     unit_tests/ref-output/cascades_2.ref \
     unit_tests/ref-output/cascades2_lexer_1.ref \
     unit_tests/ref-output/cascades2_1.ref \
     unit_tests/ref-output/cascades2_2.ref \
     unit_tests/ref-output/event_transforms_1.ref \
     unit_tests/ref-output/recoil_kinematics_1.ref \
     unit_tests/ref-output/recoil_kinematics_2.ref \
     unit_tests/ref-output/recoil_kinematics_3.ref \
     unit_tests/ref-output/recoil_kinematics_4.ref \
     unit_tests/ref-output/recoil_kinematics_5.ref \
     unit_tests/ref-output/resonance_insertion_1.ref \
     unit_tests/ref-output/resonance_insertion_2.ref \
     unit_tests/ref-output/resonance_insertion_3.ref \
     unit_tests/ref-output/resonance_insertion_4.ref \
     unit_tests/ref-output/resonance_insertion_5.ref \
     unit_tests/ref-output/resonance_insertion_6.ref \
     unit_tests/ref-output/isr_handler_1.ref \
     unit_tests/ref-output/isr_handler_2.ref \
     unit_tests/ref-output/isr_handler_3.ref \
     unit_tests/ref-output/epa_handler_1.ref \
     unit_tests/ref-output/epa_handler_2.ref \
     unit_tests/ref-output/epa_handler_3.ref \
     unit_tests/ref-output/decays_1.ref \
     unit_tests/ref-output/decays_2.ref \
     unit_tests/ref-output/decays_3.ref \
     unit_tests/ref-output/decays_4.ref \
     unit_tests/ref-output/decays_5.ref \
     unit_tests/ref-output/decays_6.ref \
     unit_tests/ref-output/shower_1.ref \
     unit_tests/ref-output/shower_2.ref \
     unit_tests/ref-output/shower_base_1.ref \
     unit_tests/ref-output/events_1.ref \
     unit_tests/ref-output/events_2.ref \
     unit_tests/ref-output/events_3.ref \
     unit_tests/ref-output/events_4.ref \
     unit_tests/ref-output/events_5.ref \
     unit_tests/ref-output/events_6.ref \
     unit_tests/ref-output/events_7.ref \
     unit_tests/ref-output/hep_events_1.ref \
     unit_tests/ref-output/eio_data_1.ref \
     unit_tests/ref-output/eio_data_2.ref \
     unit_tests/ref-output/eio_base_1.ref \
     unit_tests/ref-output/eio_direct_1.ref \
     unit_tests/ref-output/eio_raw_1.ref \
     unit_tests/ref-output/eio_raw_2.ref \
     unit_tests/ref-output/eio_checkpoints_1.ref \
     unit_tests/ref-output/eio_lhef_1.ref \
     unit_tests/ref-output/eio_lhef_2.ref \
     unit_tests/ref-output/eio_lhef_3.ref \
     unit_tests/ref-output/eio_lhef_4.ref \
     unit_tests/ref-output/eio_lhef_5.ref \
     unit_tests/ref-output/eio_lhef_6.ref \
     unit_tests/ref-output/eio_stdhep_1.ref \
     unit_tests/ref-output/eio_stdhep_2.ref \
     unit_tests/ref-output/eio_stdhep_3.ref \
     unit_tests/ref-output/eio_stdhep_4.ref \
     unit_tests/ref-output/eio_hepmc_1.ref \
     unit_tests/ref-output/eio_hepmc_2.ref \
     unit_tests/ref-output/eio_lcio_1.ref \
     unit_tests/ref-output/eio_lcio_2.ref \
     unit_tests/ref-output/eio_ascii_1.ref \
     unit_tests/ref-output/eio_ascii_2.ref \
     unit_tests/ref-output/eio_ascii_3.ref \
     unit_tests/ref-output/eio_ascii_4.ref \
     unit_tests/ref-output/eio_ascii_5.ref \
     unit_tests/ref-output/eio_ascii_6.ref \
     unit_tests/ref-output/eio_ascii_7.ref \
     unit_tests/ref-output/eio_ascii_8.ref \
     unit_tests/ref-output/eio_ascii_9.ref \
     unit_tests/ref-output/eio_ascii_10.ref \
     unit_tests/ref-output/eio_weights_1.ref \
     unit_tests/ref-output/eio_weights_2.ref \
     unit_tests/ref-output/eio_weights_3.ref \
     unit_tests/ref-output/eio_dump_1.ref \
     unit_tests/ref-output/iterations_1.ref \
     unit_tests/ref-output/iterations_2.ref \
     unit_tests/ref-output/rt_data_1.ref \
     unit_tests/ref-output/rt_data_2.ref \
     unit_tests/ref-output/rt_data_3.ref \
     unit_tests/ref-output/rt_data_4.ref \
     unit_tests/ref-output/rt_data_5.ref \
     unit_tests/ref-output/rt_data_6.ref \
     unit_tests/ref-output/rt_data_7.ref \
     unit_tests/ref-output/rt_data_8.ref \
     unit_tests/ref-output/rt_data_9.ref \
     unit_tests/ref-output/rt_data_10.ref \
     unit_tests/ref-output/rt_data_11.ref \
     unit_tests/ref-output/dispatch_1.ref \
     unit_tests/ref-output/dispatch_2.ref \
     unit_tests/ref-output/dispatch_7.ref \
     unit_tests/ref-output/dispatch_8.ref \
     unit_tests/ref-output/dispatch_10.ref \
     unit_tests/ref-output/dispatch_11.ref \
     unit_tests/ref-output/dispatch_rng_1.ref \
     unit_tests/ref-output/dispatch_phs_1.ref \
     unit_tests/ref-output/dispatch_phs_2.ref \
     unit_tests/ref-output/dispatch_mci_1.ref \
     unit_tests/ref-output/dispatch_transforms_1.ref \
     unit_tests/ref-output/dispatch_transforms_2.ref \
     unit_tests/ref-output/process_configurations_1.ref \
     unit_tests/ref-output/process_configurations_2.ref \
     unit_tests/ref-output/event_streams_1.ref \
     unit_tests/ref-output/event_streams_2.ref \
     unit_tests/ref-output/event_streams_3.ref \
     unit_tests/ref-output/event_streams_4.ref \
     unit_tests/ref-output/compilations_1.ref \
     unit_tests/ref-output/compilations_2.ref \
     unit_tests/ref-output/compilations_3.ref \
     unit_tests/ref-output/compilations_static_1.ref \
     unit_tests/ref-output/compilations_static_2.ref \
     unit_tests/ref-output/integrations_1.ref \
     unit_tests/ref-output/integrations_2.ref \
     unit_tests/ref-output/integrations_3.ref \
     unit_tests/ref-output/integrations_4.ref \
     unit_tests/ref-output/integrations_5.ref \
     unit_tests/ref-output/integrations_6.ref \
     unit_tests/ref-output/integrations_7.ref \
     unit_tests/ref-output/integrations_8.ref \
     unit_tests/ref-output/integrations_9.ref \
     unit_tests/ref-output/integrations_history_1.ref \
     unit_tests/ref-output/restricted_subprocesses_1.ref \
     unit_tests/ref-output/restricted_subprocesses_2.ref \
     unit_tests/ref-output/restricted_subprocesses_3.ref \
     unit_tests/ref-output/restricted_subprocesses_4.ref \
     unit_tests/ref-output/restricted_subprocesses_5.ref \
     unit_tests/ref-output/restricted_subprocesses_6.ref \
     unit_tests/ref-output/simulations_1.ref \
     unit_tests/ref-output/simulations_2.ref \
     unit_tests/ref-output/simulations_3.ref \
     unit_tests/ref-output/simulations_4.ref \
     unit_tests/ref-output/simulations_5.ref \
     unit_tests/ref-output/simulations_6.ref \
     unit_tests/ref-output/simulations_7.ref \
     unit_tests/ref-output/simulations_8.ref \
     unit_tests/ref-output/simulations_9.ref \
     unit_tests/ref-output/simulations_10.ref \
     unit_tests/ref-output/simulations_11.ref \
     unit_tests/ref-output/simulations_12.ref \
     unit_tests/ref-output/simulations_13.ref \
     unit_tests/ref-output/simulations_14.ref \
     unit_tests/ref-output/simulations_15.ref \
     unit_tests/ref-output/commands_1.ref \
     unit_tests/ref-output/commands_2.ref \
     unit_tests/ref-output/commands_3.ref \
     unit_tests/ref-output/commands_4.ref \
     unit_tests/ref-output/commands_5.ref \
     unit_tests/ref-output/commands_6.ref \
     unit_tests/ref-output/commands_7.ref \
     unit_tests/ref-output/commands_8.ref \
     unit_tests/ref-output/commands_9.ref \
     unit_tests/ref-output/commands_10.ref \
     unit_tests/ref-output/commands_11.ref \
     unit_tests/ref-output/commands_12.ref \
     unit_tests/ref-output/commands_13.ref \
     unit_tests/ref-output/commands_14.ref \
     unit_tests/ref-output/commands_15.ref \
     unit_tests/ref-output/commands_16.ref \
     unit_tests/ref-output/commands_17.ref \
     unit_tests/ref-output/commands_18.ref \
     unit_tests/ref-output/commands_19.ref \
     unit_tests/ref-output/commands_20.ref \
     unit_tests/ref-output/commands_21.ref \
     unit_tests/ref-output/commands_22.ref \
     unit_tests/ref-output/commands_23.ref \
     unit_tests/ref-output/commands_24.ref \
     unit_tests/ref-output/commands_25.ref \
     unit_tests/ref-output/commands_26.ref \
     unit_tests/ref-output/commands_27.ref \
     unit_tests/ref-output/commands_28.ref \
     unit_tests/ref-output/commands_29.ref \
     unit_tests/ref-output/commands_30.ref \
     unit_tests/ref-output/commands_31.ref \
     unit_tests/ref-output/commands_32.ref \
     unit_tests/ref-output/commands_33.ref \
     unit_tests/ref-output/commands_34.ref \
     unit_tests/ref-output/jets_1.ref \
     unit_tests/ref-output/hepmc_interface_1.ref \
     unit_tests/ref-output/lcio_interface_1.ref \
     unit_tests/ref-output/ttv_formfactors_1.ref \
     unit_tests/ref-output/ttv_formfactors_2.ref \
     unit_tests/ref-output/blha_1.ref \
     unit_tests/ref-output/blha_2.ref \
     unit_tests/ref-output/blha_3.ref \
     functional_tests/ref-output/pack_1.ref \
     functional_tests/ref-output/structure_1.ref \
     functional_tests/ref-output/structure_2.ref \
     functional_tests/ref-output/structure_3.ref \
     functional_tests/ref-output/structure_4.ref \
     functional_tests/ref-output/structure_5.ref \
     functional_tests/ref-output/structure_6.ref \
     functional_tests/ref-output/structure_7.ref \
     functional_tests/ref-output/structure_8.ref \
     functional_tests/ref-output/vars.ref \
     functional_tests/ref-output/extpar.ref \
     functional_tests/ref-output/testproc_1.ref \
     functional_tests/ref-output/testproc_2.ref \
     functional_tests/ref-output/testproc_3.ref \
     functional_tests/ref-output/testproc_4.ref \
     functional_tests/ref-output/testproc_5.ref \
     functional_tests/ref-output/testproc_6.ref \
     functional_tests/ref-output/testproc_7.ref \
     functional_tests/ref-output/testproc_8.ref \
     functional_tests/ref-output/testproc_9.ref \
     functional_tests/ref-output/testproc_10.ref \
     functional_tests/ref-output/testproc_11.ref \
     functional_tests/ref-output/template_me_1.ref \
     functional_tests/ref-output/template_me_2.ref \
     functional_tests/ref-output/susyhit.ref \
     functional_tests/ref-output/restrictions.ref \
     functional_tests/ref-output/process_log.ref \
     functional_tests/ref-output/static_1.ref \
     functional_tests/ref-output/static_2.ref \
     functional_tests/ref-output/libraries_1.ref \
     functional_tests/ref-output/libraries_2.ref \
     functional_tests/ref-output/libraries_4.ref \
     functional_tests/ref-output/job_id_1.ref \
     functional_tests/ref-output/job_id_2.ref \
     functional_tests/ref-output/job_id_3.ref \
     functional_tests/ref-output/job_id_4.ref \
     functional_tests/ref-output/rebuild_2.ref \
     functional_tests/ref-output/rebuild_3.ref \
     functional_tests/ref-output/rebuild_4.ref \
     functional_tests/ref-output/fatal.ref \
     functional_tests/ref-output/model_change_1.ref \
     functional_tests/ref-output/model_change_2.ref \
     functional_tests/ref-output/model_scheme_1.ref \
     functional_tests/ref-output/model_test.ref \
     functional_tests/ref-output/cuts.ref \
     functional_tests/ref-output/user_cuts.ref \
     functional_tests/ref-output/user_prc_threshold_1.ref \
     functional_tests/ref-output/user_prc_threshold_2.ref \
     functional_tests/ref-output/qedtest_1.ref \
     functional_tests/ref-output/qedtest_2.ref \
     functional_tests/ref-output/qedtest_5.ref \
     functional_tests/ref-output/qedtest_6.ref \
     functional_tests/ref-output/qedtest_7.ref \
     functional_tests/ref-output/qedtest_8.ref \
     functional_tests/ref-output/qedtest_9.ref \
     functional_tests/ref-output/qedtest_10.ref \
     functional_tests/ref-output/qcdtest_4.ref \
     functional_tests/ref-output/qcdtest_5.ref \
     functional_tests/ref-output/qcdtest_6.ref \
     functional_tests/ref-output/beam_setup_1.ref \
     functional_tests/ref-output/beam_setup_2.ref \
     functional_tests/ref-output/beam_setup_3.ref \
     functional_tests/ref-output/beam_setup_4.ref \
     functional_tests/ref-output/observables_1.ref \
     functional_tests/ref-output/event_weights_1.ref \
     functional_tests/ref-output/event_weights_2.ref \
     functional_tests/ref-output/event_eff_1.ref \
     functional_tests/ref-output/event_eff_2.ref \
     functional_tests/ref-output/event_dump_1.ref \
     functional_tests/ref-output/event_dump_2.ref \
     functional_tests/ref-output/reweight_1.ref \
     functional_tests/ref-output/reweight_2.ref \
     functional_tests/ref-output/reweight_3.ref \
     functional_tests/ref-output/reweight_4.ref \
     functional_tests/ref-output/reweight_5.ref \
     functional_tests/ref-output/reweight_6.ref \
     functional_tests/ref-output/reweight_7.ref \
     functional_tests/ref-output/reweight_8.ref \
     functional_tests/ref-output/analyze_1.ref \
     functional_tests/ref-output/analyze_2.ref \
     functional_tests/ref-output/analyze_3.ref \
     functional_tests/ref-output/analyze_4.ref \
+    functional_tests/ref-output/analyze_5.ref \
     functional_tests/ref-output/colors.ref \
     functional_tests/ref-output/colors_hgg.ref \
     functional_tests/ref-output/alphas.ref \
     functional_tests/ref-output/jets_xsec.ref \
     functional_tests/ref-output/shower_err_1.ref \
     functional_tests/ref-output/parton_shower_1.ref \
     functional_tests/ref-output/pythia6_1.ref \
     functional_tests/ref-output/pythia6_2.ref \
     functional_tests/ref-output/hadronize_1.ref \
     functional_tests/ref-output/mlm_matching_fsr.ref \
     functional_tests/ref-output/mlm_pythia6_isr.ref \
     functional_tests/ref-output/hepmc_1.ref \
     functional_tests/ref-output/hepmc_2.ref \
     functional_tests/ref-output/hepmc_3.ref \
     functional_tests/ref-output/hepmc_4.ref \
     functional_tests/ref-output/hepmc_5.ref \
     functional_tests/ref-output/hepmc_6.ref \
     functional_tests/ref-output/hepmc_7.ref \
     functional_tests/ref-output/hepmc_9.ref \
     functional_tests/ref-output/hepmc_10.ref \
     functional_tests/ref-output/lhef_1.ref \
     functional_tests/ref-output/lhef_2.ref \
     functional_tests/ref-output/lhef_3.ref \
     functional_tests/ref-output/lhef_4.ref \
     functional_tests/ref-output/lhef_5.ref \
     functional_tests/ref-output/lhef_6.ref \
     functional_tests/ref-output/lhef_9.ref \
     functional_tests/ref-output/lhef_10.ref \
     functional_tests/ref-output/lhef_11.ref \
     functional_tests/ref-output/select_1.ref \
     functional_tests/ref-output/select_2.ref \
     functional_tests/ref-output/stdhep_1.ref \
     functional_tests/ref-output/stdhep_2.ref \
     functional_tests/ref-output/stdhep_3.ref \
     functional_tests/ref-output/stdhep_4.ref \
     functional_tests/ref-output/stdhep_5.ref \
     functional_tests/ref-output/stdhep_6.ref \
     functional_tests/ref-output/lcio_1.ref \
     functional_tests/ref-output/lcio_3.ref \
     functional_tests/ref-output/lcio_4.ref \
     functional_tests/ref-output/lcio_5.ref \
     functional_tests/ref-output/fatal_beam_decay.ref \
     functional_tests/ref-output/smtest_1.ref \
     functional_tests/ref-output/smtest_3.ref \
     functional_tests/ref-output/smtest_4.ref \
     functional_tests/ref-output/smtest_5.ref \
     functional_tests/ref-output/smtest_6.ref \
     functional_tests/ref-output/smtest_7.ref \
     functional_tests/ref-output/smtest_9.ref \
     functional_tests/ref-output/smtest_10.ref \
     functional_tests/ref-output/smtest_11.ref \
     functional_tests/ref-output/smtest_12.ref \
     functional_tests/ref-output/smtest_13.ref \
     functional_tests/ref-output/smtest_14.ref \
     functional_tests/ref-output/smtest_15.ref \
     functional_tests/ref-output/sm_cms_1.ref \
     functional_tests/ref-output/resonances_5.ref \
     functional_tests/ref-output/resonances_6.ref \
     functional_tests/ref-output/resonances_7.ref \
     functional_tests/ref-output/resonances_8.ref \
     functional_tests/ref-output/resonances_9.ref \
     functional_tests/ref-output/resonances_12.ref \
     functional_tests/ref-output/ufo_1.ref \
     functional_tests/ref-output/ufo_2.ref \
     functional_tests/ref-output/ufo_3.ref \
     functional_tests/ref-output/nlo_1.ref \
     functional_tests/ref-output/nlo_2.ref \
     functional_tests/ref-output/nlo_6.ref \
     functional_tests/ref-output/real_partition_1.ref \
     functional_tests/ref-output/fks_res_2.ref \
     functional_tests/ref-output/openloops_1.ref \
     functional_tests/ref-output/openloops_2.ref \
     functional_tests/ref-output/openloops_4.ref \
     functional_tests/ref-output/openloops_5.ref \
     functional_tests/ref-output/openloops_6.ref \
     functional_tests/ref-output/openloops_7.ref \
     functional_tests/ref-output/openloops_8.ref \
     functional_tests/ref-output/openloops_9.ref \
     functional_tests/ref-output/openloops_10.ref \
     functional_tests/ref-output/recola_1.ref \
     functional_tests/ref-output/recola_2.ref \
     functional_tests/ref-output/recola_3.ref \
     functional_tests/ref-output/recola_4.ref \
     functional_tests/ref-output/recola_5.ref \
     functional_tests/ref-output/recola_6.ref \
     functional_tests/ref-output/recola_7.ref \
     functional_tests/ref-output/recola_8.ref \
     functional_tests/ref-output/nlo_decay_1.ref \
     functional_tests/ref-output/mssmtest_1.ref \
     functional_tests/ref-output/mssmtest_2.ref \
     functional_tests/ref-output/mssmtest_3.ref \
     functional_tests/ref-output/spincor_1.ref \
     functional_tests/ref-output/show_1.ref \
     functional_tests/ref-output/show_2.ref \
     functional_tests/ref-output/show_3.ref \
     functional_tests/ref-output/show_4.ref \
     functional_tests/ref-output/show_5.ref \
     functional_tests/ref-output/method_ovm_1.ref \
     functional_tests/ref-output/multi_comp_4.ref \
     functional_tests/ref-output/flvsum_1.ref \
     functional_tests/ref-output/br_redef_1.ref \
     functional_tests/ref-output/decay_err_1.ref \
     functional_tests/ref-output/decay_err_2.ref \
     functional_tests/ref-output/decay_err_3.ref \
     functional_tests/ref-output/polarized_1.ref \
     functional_tests/ref-output/circe1_1.ref \
     functional_tests/ref-output/circe1_2.ref \
     functional_tests/ref-output/circe1_3.ref \
     functional_tests/ref-output/circe1_6.ref \
     functional_tests/ref-output/circe1_10.ref \
     functional_tests/ref-output/circe1_errors_1.ref \
     functional_tests/ref-output/circe2_1.ref \
     functional_tests/ref-output/circe2_2.ref \
     functional_tests/ref-output/circe2_3.ref \
     functional_tests/ref-output/isr_1.ref \
     functional_tests/ref-output/epa_1.ref \
     functional_tests/ref-output/epa_2.ref \
     functional_tests/ref-output/isr_epa_1.ref \
     functional_tests/ref-output/ep_3.ref \
     functional_tests/ref-output/ewa_4.ref \
     functional_tests/ref-output/gaussian_1.ref \
     functional_tests/ref-output/gaussian_2.ref \
     functional_tests/ref-output/beam_events_1.ref \
     functional_tests/ref-output/beam_events_4.ref \
     functional_tests/ref-output/energy_scan_1.ref \
     functional_tests/ref-output/cascades2_phs_1.ref
 
 # Reference files that depend on the numerical precision
 REF_OUTPUT_FILES_DOUBLE = \
     functional_tests/ref-output-double/qedtest_3.ref \
     functional_tests/ref-output-double/qedtest_4.ref \
     functional_tests/ref-output-double/qcdtest_1.ref \
     functional_tests/ref-output-double/qcdtest_2.ref \
     functional_tests/ref-output-double/qcdtest_3.ref \
     functional_tests/ref-output-double/smtest_2.ref \
     functional_tests/ref-output-double/smtest_8.ref \
     functional_tests/ref-output-double/observables_2.ref \
     functional_tests/ref-output-double/colors_2.ref \
     functional_tests/ref-output-double/resonances_1.ref \
     functional_tests/ref-output-double/resonances_2.ref \
     functional_tests/ref-output-double/resonances_3.ref \
     functional_tests/ref-output-double/resonances_4.ref \
     functional_tests/ref-output-double/resonances_10.ref \
     functional_tests/ref-output-double/resonances_11.ref \
     functional_tests/ref-output-double/beam_setup_5.ref \
     functional_tests/ref-output-double/nlo_3.ref \
     functional_tests/ref-output-double/nlo_4.ref \
     functional_tests/ref-output-double/nlo_5.ref \
     functional_tests/ref-output-double/fks_res_1.ref \
     functional_tests/ref-output-double/fks_res_3.ref \
     functional_tests/ref-output-double/openloops_3.ref \
     functional_tests/ref-output-double/powheg_1.ref \
     functional_tests/ref-output-double/defaultcuts.ref \
     functional_tests/ref-output-double/parton_shower_2.ref \
     functional_tests/ref-output-double/helicity.ref \
     functional_tests/ref-output-double/lhef_7.ref \
     functional_tests/ref-output-double/hepmc_8.ref \
     functional_tests/ref-output-double/lcio_2.ref \
     functional_tests/ref-output-double/multi_comp_1.ref \
     functional_tests/ref-output-double/multi_comp_2.ref \
     functional_tests/ref-output-double/multi_comp_3.ref \
     functional_tests/ref-output-double/pdf_builtin.ref \
     functional_tests/ref-output-double/lhapdf5.ref \
     functional_tests/ref-output-double/lhapdf6.ref \
     functional_tests/ref-output-double/ep_1.ref \
     functional_tests/ref-output-double/ep_2.ref \
     functional_tests/ref-output-double/circe1_4.ref \
     functional_tests/ref-output-double/circe1_5.ref \
     functional_tests/ref-output-double/circe1_7.ref \
     functional_tests/ref-output-double/circe1_8.ref \
     functional_tests/ref-output-double/circe1_9.ref \
     functional_tests/ref-output-double/circe1_photons_1.ref \
     functional_tests/ref-output-double/circe1_photons_2.ref \
     functional_tests/ref-output-double/circe1_photons_3.ref \
     functional_tests/ref-output-double/circe1_photons_4.ref \
     functional_tests/ref-output-double/circe1_photons_5.ref \
     functional_tests/ref-output-double/isr_2.ref \
     functional_tests/ref-output-double/isr_3.ref \
     functional_tests/ref-output-double/isr_4.ref \
     functional_tests/ref-output-double/isr_5.ref \
     functional_tests/ref-output-double/pythia6_3.ref \
     functional_tests/ref-output-double/pythia6_4.ref \
     functional_tests/ref-output-double/tauola_1.ref \
     functional_tests/ref-output-double/tauola_2.ref \
     functional_tests/ref-output-double/mlm_matching_isr.ref \
     functional_tests/ref-output-double/ewa_1.ref \
     functional_tests/ref-output-double/ewa_2.ref \
     functional_tests/ref-output-double/ewa_3.ref \
     functional_tests/ref-output-double/ilc.ref \
     functional_tests/ref-output-double/beam_events_2.ref \
     functional_tests/ref-output-double/beam_events_3.ref
 
 REF_OUTPUT_FILES_PREC = \
     functional_tests/ref-output-prec/qedtest_3.ref \
     functional_tests/ref-output-prec/qedtest_4.ref \
     functional_tests/ref-output-prec/qcdtest_1.ref \
     functional_tests/ref-output-prec/qcdtest_2.ref \
     functional_tests/ref-output-prec/qcdtest_3.ref \
     functional_tests/ref-output-prec/smtest_2.ref \
     functional_tests/ref-output-prec/smtest_8.ref \
     functional_tests/ref-output-prec/colors_2.ref \
     functional_tests/ref-output-prec/beam_setup_5.ref \
     functional_tests/ref-output-prec/nlo_3.ref \
     functional_tests/ref-output-prec/nlo_4.ref \
     functional_tests/ref-output-prec/fks_res_1.ref \
     functional_tests/ref-output-prec/fks_res_3.ref \
     functional_tests/ref-output-prec/openloops_3.ref \
     functional_tests/ref-output-prec/defaultcuts.ref \
     functional_tests/ref-output-prec/parton_shower_2.ref \
     functional_tests/ref-output-prec/helicity.ref \
     functional_tests/ref-output-prec/lhef_7.ref \
     functional_tests/ref-output-prec/multi_comp_1.ref \
     functional_tests/ref-output-prec/multi_comp_2.ref \
     functional_tests/ref-output-prec/multi_comp_3.ref \
     functional_tests/ref-output-prec/pdf_builtin.ref \
     functional_tests/ref-output-prec/lhapdf5.ref \
     functional_tests/ref-output-prec/lhapdf6.ref \
     functional_tests/ref-output-prec/ep_1.ref \
     functional_tests/ref-output-prec/ep_2.ref \
     functional_tests/ref-output-prec/ilc.ref \
     functional_tests/ref-output-prec/circe1_9.ref \
     functional_tests/ref-output-prec/circe1_photons_1.ref \
     functional_tests/ref-output-prec/circe1_photons_2.ref \
     functional_tests/ref-output-prec/circe1_photons_3.ref \
     functional_tests/ref-output-prec/circe1_photons_4.ref \
     functional_tests/ref-output-prec/circe1_photons_5.ref \
     functional_tests/ref-output-prec/ewa_1.ref
 
 REF_OUTPUT_FILES_EXT = \
     functional_tests/ref-output-ext/observables_2.ref \
     functional_tests/ref-output-ext/resonances_1.ref \
     functional_tests/ref-output-ext/resonances_2.ref \
     functional_tests/ref-output-ext/resonances_3.ref \
     functional_tests/ref-output-ext/resonances_4.ref \
     functional_tests/ref-output-ext/resonances_10.ref \
     functional_tests/ref-output-ext/resonances_11.ref \
     functional_tests/ref-output-ext/circe1_4.ref \
     functional_tests/ref-output-ext/circe1_5.ref \
     functional_tests/ref-output-ext/circe1_7.ref \
     functional_tests/ref-output-ext/circe1_8.ref \
     functional_tests/ref-output-ext/isr_2.ref \
     functional_tests/ref-output-ext/isr_3.ref \
     functional_tests/ref-output-ext/isr_4.ref \
     functional_tests/ref-output-ext/isr_5.ref \
     functional_tests/ref-output-ext/nlo_5.ref \
     functional_tests/ref-output-ext/powheg_1.ref \
     functional_tests/ref-output-ext/pythia6_3.ref \
     functional_tests/ref-output-ext/pythia6_4.ref \
     functional_tests/ref-output-ext/tauola_1.ref \
     functional_tests/ref-output-ext/tauola_2.ref \
     functional_tests/ref-output-ext/ewa_2.ref \
     functional_tests/ref-output-ext/ewa_3.ref \
     functional_tests/ref-output-ext/beam_events_2.ref \
     functional_tests/ref-output-ext/beam_events_3.ref \
     functional_tests/ref-output-ext/mlm_matching_isr.ref \
     functional_tests/ref-output-ext/hepmc_8.ref \
     functional_tests/ref-output-ext/lcio_2.ref
 
 REF_OUTPUT_FILES_QUAD = \
     functional_tests/ref-output-quad/observables_2.ref \
     functional_tests/ref-output-quad/resonances_1.ref \
     functional_tests/ref-output-quad/resonances_2.ref \
     functional_tests/ref-output-quad/resonances_3.ref \
     functional_tests/ref-output-quad/resonances_4.ref \
     functional_tests/ref-output-quad/resonances_10.ref \
     functional_tests/ref-output-quad/resonances_11.ref \
     functional_tests/ref-output-quad/circe1_4.ref \
     functional_tests/ref-output-quad/circe1_5.ref \
     functional_tests/ref-output-quad/circe1_7.ref \
     functional_tests/ref-output-quad/circe1_8.ref \
     functional_tests/ref-output-quad/isr_2.ref \
     functional_tests/ref-output-quad/isr_3.ref \
     functional_tests/ref-output-quad/isr_4.ref \
     functional_tests/ref-output-quad/isr_5.ref \
     functional_tests/ref-output-quad/nlo_5.ref \
     functional_tests/ref-output-quad/powheg_1.ref \
     functional_tests/ref-output-quad/pythia6_3.ref \
     functional_tests/ref-output-quad/pythia6_4.ref \
     functional_tests/ref-output-quad/tauola_1.ref \
     functional_tests/ref-output-quad/tauola_2.ref \
     functional_tests/ref-output-quad/ewa_2.ref \
     functional_tests/ref-output-quad/ewa_3.ref \
     functional_tests/ref-output-quad/beam_events_2.ref \
     functional_tests/ref-output-quad/beam_events_3.ref \
     functional_tests/ref-output-quad/mlm_matching_isr.ref \
     functional_tests/ref-output-quad/hepmc_8.ref \
     functional_tests/ref-output-quad/lcio_2.ref
 
 TESTSUITES_M4 = \
     $(MISC_TESTS_M4) \
     $(EXT_MSSM_M4) \
     $(EXT_NMSSM_M4)
 
 TESTSUITES_SIN = \
     $(MISC_TESTS_SIN) \
     $(EXT_MSSM_SIN) \
     $(EXT_NMSSM_SIN) \
     $(EXT_SHOWER_SIN) \
     $(EXT_NLO_SIN)
 
 MISC_TESTS_M4 =
 
 MISC_TESTS_SIN = \
     functional_tests/empty.sin \
     functional_tests/fatal.sin \
     functional_tests/pack_1.sin \
     functional_tests/defaultcuts.sin \
     functional_tests/cuts.sin \
     functional_tests/model_change_1.sin \
     functional_tests/model_change_2.sin \
     functional_tests/model_scheme_1.sin \
     functional_tests/model_test.sin \
     functional_tests/structure_1.sin \
     functional_tests/structure_2.sin \
     functional_tests/structure_3.sin \
     functional_tests/structure_4.sin \
     functional_tests/structure_5.sin \
     functional_tests/structure_6.sin \
     functional_tests/structure_7.sin \
     functional_tests/structure_8.sin \
     functional_tests/vars.sin \
     functional_tests/extpar.sin \
     functional_tests/testproc_1.sin \
     functional_tests/testproc_2.sin \
     functional_tests/testproc_3.sin \
     functional_tests/testproc_4.sin \
     functional_tests/testproc_5.sin \
     functional_tests/testproc_6.sin \
     functional_tests/testproc_7.sin \
     functional_tests/testproc_8.sin \
     functional_tests/testproc_9.sin \
     functional_tests/testproc_10.sin \
     functional_tests/testproc_11.sin \
     functional_tests/template_me_1.sin \
     functional_tests/template_me_2.sin \
     functional_tests/libraries_1.sin \
     functional_tests/libraries_2.sin \
     functional_tests/libraries_3.sin \
     functional_tests/libraries_4.sin \
     functional_tests/job_id_1.sin \
     functional_tests/job_id_2.sin \
     functional_tests/job_id_3.sin \
     functional_tests/job_id_4.sin \
     functional_tests/rebuild_1.sin \
     functional_tests/rebuild_2.sin \
     functional_tests/rebuild_3.sin \
     functional_tests/rebuild_4.sin \
     functional_tests/rebuild_5.sin \
     functional_tests/qedtest_1.sin \
     functional_tests/qedtest_2.sin \
     functional_tests/qedtest_3.sin \
     functional_tests/qedtest_4.sin \
     functional_tests/qedtest_5.sin \
     functional_tests/qedtest_6.sin \
     functional_tests/qedtest_7.sin \
     functional_tests/qedtest_8.sin \
     functional_tests/qedtest_9.sin \
     functional_tests/qedtest_10.sin \
     functional_tests/beam_setup_1.sin \
     functional_tests/beam_setup_2.sin \
     functional_tests/beam_setup_3.sin \
     functional_tests/beam_setup_4.sin \
     functional_tests/beam_setup_5.sin \
     functional_tests/qcdtest_1.sin \
     functional_tests/qcdtest_2.sin \
     functional_tests/qcdtest_3.sin \
     functional_tests/qcdtest_4.sin \
     functional_tests/qcdtest_5.sin \
     functional_tests/qcdtest_6.sin \
     functional_tests/observables_1.sin \
     functional_tests/observables_2.sin \
     functional_tests/event_weights_1.sin \
     functional_tests/event_weights_2.sin \
     functional_tests/event_eff_1.sin \
     functional_tests/event_eff_2.sin \
     functional_tests/event_dump_1.sin \
     functional_tests/event_dump_2.sin \
     functional_tests/reweight_1.sin \
     functional_tests/reweight_2.sin \
     functional_tests/reweight_3.sin \
     functional_tests/reweight_4.sin \
     functional_tests/reweight_5.sin \
     functional_tests/reweight_6.sin \
     functional_tests/reweight_7.sin \
     functional_tests/reweight_8.sin \
     functional_tests/analyze_1.sin \
     functional_tests/analyze_2.sin \
     functional_tests/analyze_3.sin \
     functional_tests/analyze_4.sin \
+    functional_tests/analyze_5.sin \
     functional_tests/colors.sin \
     functional_tests/colors_2.sin \
     functional_tests/colors_hgg.sin \
     functional_tests/alphas.sin \
     functional_tests/jets_xsec.sin \
     functional_tests/lhef_1.sin \
     functional_tests/lhef_2.sin \
     functional_tests/lhef_3.sin \
     functional_tests/lhef_4.sin \
     functional_tests/lhef_5.sin \
     functional_tests/lhef_6.sin \
     functional_tests/lhef_7.sin \
     functional_tests/lhef_8.sin \
     functional_tests/lhef_9.sin \
     functional_tests/lhef_10.sin \
     functional_tests/lhef_11.sin \
     functional_tests/select_1.sin \
     functional_tests/select_2.sin \
     functional_tests/shower_err_1.sin \
     functional_tests/parton_shower_1.sin \
     functional_tests/parton_shower_2.sin \
     functional_tests/pythia6_1.sin \
     functional_tests/pythia6_2.sin \
     functional_tests/pythia6_3.sin \
     functional_tests/pythia6_4.sin \
     functional_tests/hadronize_1.sin \
     functional_tests/tauola_1.sin \
     functional_tests/tauola_2.sin \
     functional_tests/mlm_matching_fsr.sin \
     functional_tests/mlm_matching_isr.sin \
     functional_tests/mlm_pythia6_isr.sin \
     functional_tests/hepmc_1.sin \
     functional_tests/hepmc_2.sin \
     functional_tests/hepmc_3.sin \
     functional_tests/hepmc_4.sin \
     functional_tests/hepmc_5.sin \
     functional_tests/hepmc_6.sin \
     functional_tests/hepmc_7.sin \
     functional_tests/hepmc_8.sin \
     functional_tests/hepmc_9.sin \
     functional_tests/hepmc_10.sin \
     functional_tests/stdhep_1.sin \
     functional_tests/stdhep_2.sin \
     functional_tests/stdhep_3.sin \
     functional_tests/stdhep_4.sin \
     functional_tests/stdhep_5.sin \
     functional_tests/stdhep_6.sin \
     functional_tests/lcio_1.sin \
     functional_tests/lcio_2.sin \
     functional_tests/lcio_3.sin \
     functional_tests/lcio_4.sin \
     functional_tests/lcio_5.sin \
     functional_tests/fatal_beam_decay.sin \
     functional_tests/smtest_1.sin \
     functional_tests/smtest_2.sin \
     functional_tests/smtest_3.sin \
     functional_tests/smtest_4.sin \
     functional_tests/smtest_5.sin \
     functional_tests/smtest_6.sin \
     functional_tests/smtest_7.sin \
     functional_tests/smtest_8.sin \
     functional_tests/smtest_9.sin \
     functional_tests/smtest_10.sin \
     functional_tests/smtest_11.sin \
     functional_tests/smtest_12.sin \
     functional_tests/smtest_13.sin \
     functional_tests/smtest_14.sin \
     functional_tests/smtest_15.sin \
     functional_tests/resonances_1.sin \
     functional_tests/resonances_2.sin \
     functional_tests/resonances_3.sin \
     functional_tests/resonances_4.sin \
     functional_tests/resonances_5.sin \
     functional_tests/resonances_6.sin \
     functional_tests/resonances_7.sin \
     functional_tests/resonances_8.sin \
     functional_tests/resonances_9.sin \
     functional_tests/resonances_10.sin \
     functional_tests/resonances_11.sin \
     functional_tests/resonances_12.sin \
     functional_tests/sm_cms_1.sin \
     functional_tests/ufo_1.sin \
     functional_tests/ufo_2.sin \
     functional_tests/ufo_3.sin \
     functional_tests/nlo_1.sin \
     functional_tests/nlo_2.sin \
     functional_tests/nlo_3.sin \
     functional_tests/nlo_4.sin \
     functional_tests/nlo_5.sin \
     functional_tests/nlo_6.sin \
     functional_tests/nlo_decay_1.sin \
     functional_tests/real_partition_1.sin \
     functional_tests/fks_res_1.sin \
     functional_tests/fks_res_2.sin \
     functional_tests/fks_res_3.sin \
     functional_tests/openloops_1.sin \
     functional_tests/openloops_2.sin \
     functional_tests/openloops_3.sin \
     functional_tests/openloops_4.sin \
     functional_tests/openloops_5.sin \
     functional_tests/openloops_6.sin \
     functional_tests/openloops_7.sin \
     functional_tests/openloops_8.sin \
     functional_tests/openloops_9.sin \
     functional_tests/openloops_10.sin \
     functional_tests/recola_1.sin \
     functional_tests/recola_2.sin \
     functional_tests/recola_3.sin \
     functional_tests/recola_4.sin \
     functional_tests/recola_5.sin \
     functional_tests/recola_6.sin \
     functional_tests/recola_7.sin \
     functional_tests/recola_8.sin \
     functional_tests/powheg_1.sin \
     functional_tests/mssmtest_1.sin \
     functional_tests/mssmtest_2.sin \
     functional_tests/mssmtest_3.sin \
     functional_tests/spincor_1.sin \
     functional_tests/show_1.sin \
     functional_tests/show_2.sin \
     functional_tests/show_3.sin \
     functional_tests/show_4.sin \
     functional_tests/show_5.sin \
     functional_tests/method_ovm_1.sin \
     functional_tests/multi_comp_1.sin \
     functional_tests/multi_comp_2.sin \
     functional_tests/multi_comp_3.sin \
     functional_tests/multi_comp_4.sin \
     functional_tests/flvsum_1.sin \
     functional_tests/br_redef_1.sin \
     functional_tests/decay_err_1.sin \
     functional_tests/decay_err_2.sin \
     functional_tests/decay_err_3.sin \
     functional_tests/polarized_1.sin \
     functional_tests/pdf_builtin.sin \
     functional_tests/lhapdf5.sin \
     functional_tests/lhapdf6.sin \
     functional_tests/ep_1.sin \
     functional_tests/ep_2.sin \
     functional_tests/ep_3.sin \
     functional_tests/circe1_1.sin \
     functional_tests/circe1_2.sin \
     functional_tests/circe1_3.sin \
     functional_tests/circe1_4.sin \
     functional_tests/circe1_5.sin \
     functional_tests/circe1_6.sin \
     functional_tests/circe1_7.sin \
     functional_tests/circe1_8.sin \
     functional_tests/circe1_9.sin \
     functional_tests/circe1_10.sin \
     functional_tests/circe1_photons_1.sin \
     functional_tests/circe1_photons_2.sin \
     functional_tests/circe1_photons_3.sin \
     functional_tests/circe1_photons_4.sin \
     functional_tests/circe1_photons_5.sin \
     functional_tests/circe1_errors_1.sin \
     functional_tests/circe2_1.sin \
     functional_tests/circe2_2.sin \
     functional_tests/circe2_3.sin \
     functional_tests/isr_1.sin \
     functional_tests/isr_2.sin \
     functional_tests/isr_3.sin \
     functional_tests/isr_4.sin \
     functional_tests/isr_5.sin \
     functional_tests/epa_1.sin \
     functional_tests/epa_2.sin \
     functional_tests/isr_epa_1.sin \
     functional_tests/ewa_1.sin \
     functional_tests/ewa_2.sin \
     functional_tests/ewa_3.sin \
     functional_tests/ewa_4.sin \
     functional_tests/ilc.sin \
     functional_tests/gaussian_1.sin \
     functional_tests/gaussian_2.sin \
     functional_tests/beam_events_1.sin \
     functional_tests/beam_events_2.sin \
     functional_tests/beam_events_3.sin \
     functional_tests/beam_events_4.sin \
     functional_tests/energy_scan_1.sin \
     functional_tests/susyhit.sin \
     functional_tests/restrictions.sin \
     functional_tests/helicity.sin \
     functional_tests/process_log.sin \
     functional_tests/static_1.sin \
     functional_tests/static_1.exe.sin \
     functional_tests/static_2.sin \
     functional_tests/static_2.exe.sin \
     functional_tests/user_cuts.sin \
     functional_tests/user_prc_threshold_1.sin \
     functional_tests/cascades2_phs_1.sin \
     functional_tests/user_prc_threshold_2.sin \
     ilc_ext.sin
 
 EXT_MSSM_M4 = \
     mssm_ext-ee.m4 mssm_ext-ee2.m4 \
     mssm_ext-en.m4 mssm_ext-tn.m4 \
     mssm_ext-uu.m4 mssm_ext-uu2.m4 mssm_ext-uuckm.m4 \
     mssm_ext-dd.m4 mssm_ext-dd2.m4 mssm_ext-ddckm.m4 \
     mssm_ext-bb.m4 mssm_ext-bt.m4 mssm_ext-tt.m4 \
     mssm_ext-ug.m4 mssm_ext-dg.m4 \
     mssm_ext-aa.m4 mssm_ext-wa.m4 mssm_ext-za.m4 \
     mssm_ext-ww.m4 mssm_ext-wz.m4 mssm_ext-zz.m4 \
     mssm_ext-gg.m4 mssm_ext-ga.m4 mssm_ext-gw.m4 mssm_ext-gz.m4
 
 EXT_NMSSM_M4 = \
     nmssm_ext-aa.m4  nmssm_ext-bb1.m4 nmssm_ext-bb2.m4 \
     nmssm_ext-bt.m4  nmssm_ext-dd1.m4 \
     nmssm_ext-dd2.m4 nmssm_ext-ee1.m4 \
     nmssm_ext-ee2.m4 nmssm_ext-en.m4  \
     nmssm_ext-ga.m4  nmssm_ext-gg.m4  \
     nmssm_ext-gw.m4  nmssm_ext-gz.m4  \
     nmssm_ext-qg.m4  nmssm_ext-tn.m4  \
     nmssm_ext-tt1.m4 nmssm_ext-tt2.m4 \
     nmssm_ext-uu1.m4 nmssm_ext-uu2.m4 \
     nmssm_ext-wa.m4  nmssm_ext-ww1.m4 nmssm_ext-ww2.m4 \
     nmssm_ext-wz.m4  nmssm_ext-za.m4  \
     nmssm_ext-zz1.m4 nmssm_ext-zz2.m4
 
 EXT_MSSM_SIN = $(EXT_MSSM_M4:.m4=.sin)
 EXT_NMSSM_SIN = $(EXT_NMSSM_M4:.m4=.sin)
 
 EXT_SHOWER_SIN = \
     shower_1_norad.sin \
     shower_2_aall.sin \
     shower_3_bb.sin \
     shower_3_jj.sin \
     shower_3_qqqq.sin \
     shower_3_tt.sin \
     shower_3_z.sin \
     shower_3_z_nu.sin \
     shower_3_z_tau.sin \
     shower_4_ee.sin \
     shower_5.sin \
     shower_6.sin
 
 EXT_NLO_SIN = \
     nlo_decay_tbw.sin \
     nlo_tt.sin \
     nlo_tt_powheg.sin \
     nlo_tt_powheg_sudakov.sin \
     nlo_uu.sin \
     nlo_uu_powheg.sin \
     nlo_qq_powheg.sin \
     nlo_threshold.sin \
     nlo_threshold_factorized.sin \
     nlo_methods_gosam.sin \
     nlo_jets.sin \
     nlo_settings.sin \
     nlo_eejj.sin \
     nlo_eejjj.sin \
     nlo_ee4j.sin \
     nlo_ee5j.sin \
     nlo_eebb.sin \
     nlo_eebbj.sin \
     nlo_eebbjj.sin \
     nlo_ee4b.sin \
     nlo_eett.sin \
     nlo_eettj.sin \
     nlo_eettjj.sin \
     nlo_eettjjj.sin \
     nlo_eettbb.sin \
     nlo_eetta.sin \
     nlo_eettaa.sin \
     nlo_eettaj.sin \
     nlo_eettajj.sin \
     nlo_eettaz.sin \
     nlo_eettah.sin \
     nlo_eettz.sin \
     nlo_eettzj.sin \
     nlo_eettzjj.sin \
     nlo_eettzz.sin \
     nlo_eettww.sin \
     nlo_eettwmjj.sin \
     nlo_eettwpjj.sin \
     nlo_eetth.sin \
     nlo_eetthj.sin \
     nlo_eetthjj.sin \
     nlo_eetthh.sin \
     nlo_eetthz.sin \
     nlo_ee4t.sin \
     nlo_ee4tj.sin
 
 all-local: $(TESTSUITES_SIN)
 
 if M4_AVAILABLE
 SUFFIXES = .m4 .sin
 .m4.sin:
 	$(M4) $(srcdir)/$(TESTSUITE_MACROS) $< > $@
 endif M4_AVAILABLE
 
Index: trunk/share/tests/unit_tests/ref-output/rt_data_1.ref
===================================================================
--- trunk/share/tests/unit_tests/ref-output/rt_data_1.ref	(revision 8163)
+++ trunk/share/tests/unit_tests/ref-output/rt_data_1.ref	(revision 8164)
@@ -1,416 +1,417 @@
 * Test output: rt_data_1
 *   Purpose: initialize global runtime data
 
 ========================================================================
  Runtime data:
 ========================================================================
 [undefined] sqrts = [unknown real]
 luminosity =  0.000000000000E+00
 ?sf_trace = false
 $sf_trace_file = ""
 ?sf_allow_s_mapping = true
 $lhapdf_dir = ""
 $lhapdf_file = ""
 $lhapdf_photon_file = ""
 lhapdf_member = 0
 lhapdf_photon_scheme = 0
 $pdf_builtin_set = "CTEQ6L"
 ?hoppet_b_matching = false
 isr_alpha =  0.000000000000E+00
 isr_q_max =  0.000000000000E+00
 isr_mass =  0.000000000000E+00
 isr_order = 3
 ?isr_recoil = false
 ?isr_keep_energy = false
 ?isr_handler = false
 $isr_handler_mode = "trivial"
 epa_alpha =  0.000000000000E+00
 epa_x_min =  0.000000000000E+00
 epa_q_min =  0.000000000000E+00
 epa_q_max =  0.000000000000E+00
 epa_mass =  0.000000000000E+00
 ?epa_recoil = false
 ?epa_keep_energy = false
 ?epa_handler = false
 $epa_handler_mode = "trivial"
 ewa_x_min =  0.000000000000E+00
 ewa_pt_max =  0.000000000000E+00
 ewa_mass =  0.000000000000E+00
 ?ewa_recoil = false
 ?ewa_keep_energy = false
 ?circe1_photon1 = false
 ?circe1_photon2 = false
 [undefined] circe1_sqrts = [unknown real]
 ?circe1_generate = true
 ?circe1_map = true
 circe1_mapping_slope =  2.000000000000E+00
 circe1_eps =  1.000000000000E-05
 circe1_ver = 0
 circe1_rev = 0
 $circe1_acc = "SBAND"
 circe1_chat = 0
 ?circe1_with_radiation = false
 ?circe2_polarized = true
 [undefined] $circe2_file = [unknown string]
 $circe2_design = "*"
 gaussian_spread1 =  0.000000000000E+00
 gaussian_spread2 =  0.000000000000E+00
 [undefined] $beam_events_file = [unknown string]
 ?beam_events_warn_eof = true
 ?energy_scan_normalize = false
 ?logging => false
 [undefined] $job_id = [unknown string]
 [undefined] $compile_workspace = [unknown string]
 seed = 0
 [undefined] $model_name = [unknown string]
 [undefined] process_num_id = [unknown integer]
 $method = "omega"
 ?report_progress = true
 [user variable] ?me_verbose = false
 $restrictions = ""
 ?omega_write_phs_output = false
 $omega_flags = ""
 ?read_color_factors = true
 ?slha_read_input = true
 ?slha_read_spectrum = true
 ?slha_read_decays = false
 [undefined] $library_name = [unknown string]
 ?alphas_is_fixed = true
 ?alphas_from_lhapdf = false
 ?alphas_from_pdf_builtin = false
 alphas_order = 0
 alphas_nf = 5
 ?alphas_from_mz = false
 ?alphas_from_lambda_qcd = false
 lambda_qcd =  2.000000000000E-01
 ?fatal_beam_decay = true
 ?helicity_selection_active = true
 helicity_selection_threshold =  1.000000000000E+10
 helicity_selection_cutoff = 1000
 $rng_method = "tao"
 ?vis_diags = false
 ?vis_diags_color = false
 ?check_event_file = true
 $event_file_version = ""
 n_events = 0
 event_index_offset = 0
 ?unweighted = true
 safety_factor =  1.000000000000E+00
 ?negative_weights = false
 ?resonance_history = false
 resonance_on_shell_limit =  4.000000000000E+00
 resonance_on_shell_turnoff =  0.000000000000E+00
 resonance_background_factor =  1.000000000000E+00
 ?keep_beams = false
 ?keep_remnants = true
 ?recover_beams = true
 ?update_event = false
 ?update_sqme = false
 ?update_weight = false
 ?use_alphas_from_file = false
 ?use_scale_from_file = false
 ?allow_decays = true
 ?auto_decays = false
 auto_decays_multiplicity = 2
 ?auto_decays_radiative = false
 ?decay_rest_frame = false
 ?isotropic_decay = false
 ?diagonal_decay = false
 [undefined] decay_helicity = [unknown integer]
 ?polarized_events = false
 $polarization_mode = "helicity"
+?colorize_subevt = false
 tolerance =  0.000000000000E+00
 checkpoint = 0
 event_callback_interval = 0
 ?pacify = false
 $out_file = ""
 ?out_advance = true
 real_range* = 307
 real_precision* = 15
 real_epsilon* =  1.000000000000E-16
 real_tiny* =  1.000000000000-300
 $integration_method = "vamp"
 threshold_calls = 10
 min_calls_per_channel = 10
 min_calls_per_bin = 10
 min_bins = 3
 max_bins = 20
 ?stratified = true
 ?use_vamp_equivalences = true
 ?vamp_verbose = false
 ?vamp_history_global = true
 ?vamp_history_global_verbose = false
 ?vamp_history_channels = false
 ?vamp_history_channels_verbose = false
 $run_id = ""
 n_calls_test = 0
 ?integration_timer = true
 ?check_grid_file = true
 accuracy_goal =  0.000000000000E+00
 error_goal =  0.000000000000E+00
 relative_error_goal =  0.000000000000E+00
 integration_results_verbosity = 1
 error_threshold =  0.000000000000E+00
 channel_weights_power =  2.500000000000E-01
 [undefined] $integrate_workspace = [unknown string]
 $phs_method = "default"
 ?vis_channels = false
 ?check_phs_file = true
 $phs_file = ""
 ?phs_only = false
 phs_threshold_s =  5.000000000000E+01
 phs_threshold_t =  1.000000000000E+02
 phs_off_shell = 2
 phs_t_channel = 6
 phs_e_scale =  1.000000000000E+01
 phs_m_scale =  1.000000000000E+01
 phs_q_scale =  1.000000000000E+01
 ?phs_keep_nonresonant = true
 ?phs_step_mapping = true
 ?phs_step_mapping_exp = true
 ?phs_s_mapping = true
 ?vis_history = false
 n_bins = 20
 ?normalize_bins = false
 $obs_label = ""
 $obs_unit = ""
 $title = ""
 $description = ""
 $x_label = ""
 $y_label = ""
 graph_width_mm = 130
 graph_height_mm = 90
 ?y_log = false
 ?x_log = false
 [undefined] x_min = [unknown real]
 [undefined] x_max = [unknown real]
 [undefined] y_min = [unknown real]
 [undefined] y_max = [unknown real]
 $gmlcode_bg = ""
 $gmlcode_fg = ""
 [undefined] ?draw_histogram = [unknown logical]
 [undefined] ?draw_base = [unknown logical]
 [undefined] ?draw_piecewise = [unknown logical]
 [undefined] ?fill_curve = [unknown logical]
 [undefined] ?draw_curve = [unknown logical]
 [undefined] ?draw_errors = [unknown logical]
 [undefined] ?draw_symbols = [unknown logical]
 [undefined] $fill_options = [unknown string]
 [undefined] $draw_options = [unknown string]
 [undefined] $err_options = [unknown string]
 [undefined] $symbol = [unknown string]
 ?analysis_file_only = false
 kt_algorithm* = 0
 cambridge_algorithm* = 1
 antikt_algorithm* = 2
 genkt_algorithm* = 3
 cambridge_for_passive_algorithm* = 11
 genkt_for_passive_algorithm* = 13
 ee_kt_algorithm* = 50
 ee_genkt_algorithm* = 53
 plugin_algorithm* = 99
 undefined_jet_algorithm* = 999
 jet_algorithm = 999
 jet_r =  0.000000000000E+00
 jet_p =  0.000000000000E+00
 jet_ycut =  0.000000000000E+00
 ?keep_flavors_when_clustering = false
 $sample = ""
 $sample_normalization = "auto"
 ?sample_pacify = false
 ?sample_select = true
 sample_max_tries = 10000
 sample_split_n_evt = 0
 sample_split_n_kbytes = 0
 sample_split_index = 0
 $rescan_input_format = "raw"
 ?read_raw = true
 ?write_raw = true
 $extension_raw = "evx"
 $extension_default = "evt"
 $debug_extension = "debug"
 ?debug_process = true
 ?debug_transforms = true
 ?debug_decay = true
 ?debug_verbose = true
 $dump_extension = "pset.dat"
 ?dump_compressed = false
 ?dump_weights = false
 ?dump_summary = false
 ?dump_screen = false
 ?hepevt_ensure_order = false
 $extension_hepevt = "hepevt"
 $extension_ascii_short = "short.evt"
 $extension_ascii_long = "long.evt"
 $extension_athena = "athena.evt"
 $extension_mokka = "mokka.evt"
 $lhef_version = "2.0"
 $lhef_extension = "lhe"
 ?lhef_write_sqme_prc = true
 ?lhef_write_sqme_ref = false
 ?lhef_write_sqme_alt = true
 $extension_lha = "lha"
 $extension_hepmc = "hepmc"
 ?hepmc_output_cross_section = false
 $extension_lcio = "slcio"
 $extension_stdhep = "hep"
 $extension_stdhep_up = "up.hep"
 $extension_stdhep_ev4 = "ev4.hep"
 $extension_hepevt_verb = "hepevt.verb"
 $extension_lha_verb = "lha.verb"
 ?allow_shower = true
 ?ps_fsr_active = false
 ?ps_isr_active = false
 ?ps_taudec_active = false
 ?muli_active = false
 $shower_method = "WHIZARD"
 ?shower_verbose = false
 $ps_PYTHIA_PYGIVE = ""
 ps_mass_cutoff =  1.000000000000E+00
 ps_fsr_lambda =  2.900000000000E-01
 ps_isr_lambda =  2.900000000000E-01
 ps_max_n_flavors = 5
 ?ps_isr_alphas_running = true
 ?ps_fsr_alphas_running = true
 ps_fixed_alphas =  0.000000000000E+00
 ?ps_isr_pt_ordered = false
 ?ps_isr_angular_ordered = true
 ps_isr_primordial_kt_width =  0.000000000000E+00
 ps_isr_primordial_kt_cutoff =  5.000000000000E+00
 ps_isr_z_cutoff =  9.990000000000E-01
 ps_isr_minenergy =  1.000000000000E+00
 ps_isr_tscalefactor =  1.000000000000E+00
 ?ps_isr_only_onshell_emitted_partons = false
 ?allow_hadronization = true
 ?hadronization_active = false
 $hadronization_method = "PYTHIA6"
 hadron_enhanced_fraction =  1.000000000000E-02
 hadron_enhanced_width =  2.000000000000E+00
 ?ps_tauola_photos = false
 ?ps_tauola_transverse = false
 ?ps_tauola_dec_rad_cor = true
 ps_tauola_dec_mode1 = 0
 ps_tauola_dec_mode2 = 0
 ps_tauola_mh =  1.250000000000E+02
 ps_tauola_mix_angle =  9.000000000000E+01
 ?ps_tauola_pol_vector = false
 ?mlm_matching = false
 mlm_Qcut_ME =  0.000000000000E+00
 mlm_Qcut_PS =  0.000000000000E+00
 mlm_ptmin =  0.000000000000E+00
 mlm_etamax =  0.000000000000E+00
 mlm_Rmin =  0.000000000000E+00
 mlm_Emin =  0.000000000000E+00
 mlm_nmaxMEjets = 0
 mlm_ETclusfactor =  2.000000000000E-01
 mlm_ETclusminE =  5.000000000000E+00
 mlm_etaclusfactor =  1.000000000000E+00
 mlm_Rclusfactor =  1.000000000000E+00
 mlm_Eclusfactor =  1.000000000000E+00
 ?powheg_matching = false
 ?powheg_use_singular_jacobian = false
 powheg_grid_size_xi = 5
 powheg_grid_size_y = 5
 powheg_grid_sampling_points = 500000
 powheg_pt_min =  1.000000000000E+00
 powheg_lambda =  2.000000000000E-01
 ?powheg_rebuild_grids = false
 ?powheg_test_sudakov = false
 ?powheg_disable_sudakov = false
 ?ckkw_matching = false
 ?omega_openmp = false
 ?openmp_is_active* = false
 openmp_num_threads_default* = 1
 openmp_num_threads = 1
 ?openmp_logging = true
 ?mpi_logging = false
 $born_me_method = ""
 $loop_me_method = ""
 $correlation_me_method = ""
 $real_tree_me_method = ""
 $dglap_me_method = ""
 ?test_soft_limit = false
 ?test_coll_limit = false
 ?test_anti_coll_limit = false
 $select_alpha_regions = ""
 $virtual_selection = "Full"
 ?virtual_collinear_resonance_aware = true
 blha_top_yukawa = -1.000000000000E+00
 $blha_ew_scheme = "alpha_qed"
 openloops_verbosity = 1
 ?openloops_use_cms = true
 openloops_phs_tolerance = 7
 openloops_stability_log = 0
 ?openloops_switch_off_muon_yukawa = false
 $openloops_extra_cmd = ""
 ?openloops_use_collier = true
 ?disable_subtraction = false
 fks_dij_exp1 =  1.000000000000E+00
 fks_dij_exp2 =  1.000000000000E+00
 fks_xi_min =  1.000000000000E-07
 fks_y_max =  1.000000000000E+00
 ?vis_fks_regions = false
 fks_xi_cut =  1.000000000000E+00
 fks_delta_zero =  2.000000000000E+00
 fks_delta_i =  2.000000000000E+00
 $fks_mapping_type = "default"
 $resonances_exclude_particles = "default"
 alpha_power = 2
 alphas_power = 0
 ?combined_nlo_integration = false
 ?fixed_order_nlo_events = false
 ?check_event_weights_against_xsection = false
 ?keep_failed_events = false
 gks_multiplicity = 0
 $gosam_filter_lo = ""
 $gosam_filter_nlo = ""
 $gosam_symmetries = "family,generation"
 form_threads = 2
 form_workspace = 1000
 $gosam_fc = ""
 mult_call_real =  1.000000000000E+00
 mult_call_virt =  1.000000000000E+00
 mult_call_dglap =  1.000000000000E+00
 $dalitz_plot = ""
 $nlo_correction_type = "QCD"
 $exclude_gauge_splittings = "c:b:t:e2:e3"
 ?nlo_use_born_scale = true
 ?nlo_cut_all_sqmes = true
 ?nlo_use_real_partition = false
 real_partition_scale =  1.000000000000E+01
 $fc => "Fortran-compiler"
 $fcflags => "Fortran-flags"
 ========================================================================
  iterations = 2:5000:"gw", 3:20000
 ========================================================================
  Process library stack: [empty]
 ========================================================================
  Beam structure: [any particles]
 ========================================================================
  Cuts: [undefined]
 ------------------------------------------------------------------------
  Scale: [undefined]
 ------------------------------------------------------------------------
  Factorization scale: [undefined]
 ------------------------------------------------------------------------
  Renormalization scale: [undefined]
 ------------------------------------------------------------------------
  Weight: [undefined]
 ========================================================================
  Event selection: [undefined]
 ------------------------------------------------------------------------
  Event reweighting factor: [undefined]
 ------------------------------------------------------------------------
  Event analysis: [undefined]
 ------------------------------------------------------------------------
  Event callback: [undefined]
 ========================================================================
  Process stack: [empty]
 ========================================================================
  quit     : F
  quit_code: 0
 ========================================================================
  Logfile  : 'rt_data.log'
 ========================================================================
 
 * Test output end: rt_data_1
Index: trunk/share/tests/unit_tests/ref-output/rt_data_2.ref
===================================================================
--- trunk/share/tests/unit_tests/ref-output/rt_data_2.ref	(revision 8163)
+++ trunk/share/tests/unit_tests/ref-output/rt_data_2.ref	(revision 8164)
@@ -1,480 +1,481 @@
 * Test output: rt_data_2
 *   Purpose: initialize global runtime data and fill contents
 
 ========================================================================
  Runtime data:
 ========================================================================
 gy =>  1.000000000000E+00
 ms =>  1.250000000000E+02
 ff =>  1.500000000000E+00
 mf* =>  1.875000000000E+02
 particle* = PDG(0)
 SCALAR* = PDG(25)
 s* = PDG(25)
 FERMION* = PDG(6)
 f* = PDG(6)
 fbar* = PDG(-6)
 F* = PDG(-6)
 charged* = PDG(6, -6)
 neutral* = PDG(25)
 colored* = PDG(6, -6)
 sqrts =  1.000000000000E+03
 luminosity =  3.300000000000E+01
 ?sf_trace = false
 $sf_trace_file = ""
 ?sf_allow_s_mapping = true
 $lhapdf_dir = ""
 $lhapdf_file = ""
 $lhapdf_photon_file = ""
 lhapdf_member = 0
 lhapdf_photon_scheme = 0
 $pdf_builtin_set = "CTEQ6L"
 ?hoppet_b_matching = false
 isr_alpha =  0.000000000000E+00
 isr_q_max =  0.000000000000E+00
 isr_mass =  0.000000000000E+00
 isr_order = 3
 ?isr_recoil = false
 ?isr_keep_energy = false
 ?isr_handler = false
 $isr_handler_mode = "trivial"
 epa_alpha =  0.000000000000E+00
 epa_x_min =  0.000000000000E+00
 epa_q_min =  0.000000000000E+00
 epa_q_max =  0.000000000000E+00
 epa_mass =  0.000000000000E+00
 ?epa_recoil = false
 ?epa_keep_energy = false
 ?epa_handler = false
 $epa_handler_mode = "trivial"
 ewa_x_min =  0.000000000000E+00
 ewa_pt_max =  0.000000000000E+00
 ewa_mass =  0.000000000000E+00
 ?ewa_recoil = false
 ?ewa_keep_energy = false
 ?circe1_photon1 = false
 ?circe1_photon2 = false
 [undefined] circe1_sqrts = [unknown real]
 ?circe1_generate = true
 ?circe1_map = true
 circe1_mapping_slope =  2.000000000000E+00
 circe1_eps =  1.000000000000E-05
 circe1_ver = 0
 circe1_rev = 0
 $circe1_acc = "SBAND"
 circe1_chat = 0
 ?circe1_with_radiation = false
 ?circe2_polarized = true
 [undefined] $circe2_file = [unknown string]
 $circe2_design = "*"
 gaussian_spread1 =  0.000000000000E+00
 gaussian_spread2 =  0.000000000000E+00
 [undefined] $beam_events_file = [unknown string]
 ?beam_events_warn_eof = true
 ?energy_scan_normalize = false
 ?logging => false
 [undefined] $job_id = [unknown string]
 [undefined] $compile_workspace = [unknown string]
 seed = 0
 $model_name = "Test"
 [undefined] process_num_id = [unknown integer]
 $method = "omega"
 ?report_progress = true
 [user variable] ?me_verbose = false
 $restrictions = ""
 ?omega_write_phs_output = false
 $omega_flags = ""
 ?read_color_factors = true
 ?slha_read_input = true
 ?slha_read_spectrum = true
 ?slha_read_decays = false
 [undefined] $library_name = [unknown string]
 ?alphas_is_fixed = true
 ?alphas_from_lhapdf = false
 ?alphas_from_pdf_builtin = false
 alphas_order = 0
 alphas_nf = 5
 ?alphas_from_mz = false
 ?alphas_from_lambda_qcd = false
 lambda_qcd =  2.000000000000E-01
 ?fatal_beam_decay = true
 ?helicity_selection_active = true
 helicity_selection_threshold =  1.000000000000E+10
 helicity_selection_cutoff = 1000
 $rng_method = "tao"
 ?vis_diags = false
 ?vis_diags_color = false
 ?check_event_file = true
 $event_file_version = ""
 n_events = 0
 event_index_offset = 0
 ?unweighted = true
 safety_factor =  1.000000000000E+00
 ?negative_weights = false
 ?resonance_history = false
 resonance_on_shell_limit =  4.000000000000E+00
 resonance_on_shell_turnoff =  0.000000000000E+00
 resonance_background_factor =  1.000000000000E+00
 ?keep_beams = false
 ?keep_remnants = true
 ?recover_beams = true
 ?update_event = false
 ?update_sqme = false
 ?update_weight = false
 ?use_alphas_from_file = false
 ?use_scale_from_file = false
 ?allow_decays = true
 ?auto_decays = false
 auto_decays_multiplicity = 2
 ?auto_decays_radiative = false
 ?decay_rest_frame = false
 ?isotropic_decay = false
 ?diagonal_decay = false
 [undefined] decay_helicity = [unknown integer]
 ?polarized_events = false
 $polarization_mode = "helicity"
+?colorize_subevt = false
 tolerance =  0.000000000000E+00
 checkpoint = 0
 event_callback_interval = 0
 ?pacify = false
 $out_file = ""
 ?out_advance = true
 real_range* = 307
 real_precision* = 15
 real_epsilon* =  1.000000000000E-16
 real_tiny* =  1.000000000000-300
 $integration_method = "vamp"
 threshold_calls = 10
 min_calls_per_channel = 10
 min_calls_per_bin = 10
 min_bins = 3
 max_bins = 20
 ?stratified = true
 ?use_vamp_equivalences = true
 ?vamp_verbose = false
 ?vamp_history_global = true
 ?vamp_history_global_verbose = false
 ?vamp_history_channels = false
 ?vamp_history_channels_verbose = false
 $run_id = "run1"
 n_calls_test = 0
 ?integration_timer = true
 ?check_grid_file = true
 accuracy_goal =  0.000000000000E+00
 error_goal =  0.000000000000E+00
 relative_error_goal =  0.000000000000E+00
 integration_results_verbosity = 1
 error_threshold =  0.000000000000E+00
 channel_weights_power =  2.500000000000E-01
 [undefined] $integrate_workspace = [unknown string]
 $phs_method = "default"
 ?vis_channels = false
 ?check_phs_file = true
 $phs_file = ""
 ?phs_only = false
 phs_threshold_s =  5.000000000000E+01
 phs_threshold_t =  1.000000000000E+02
 phs_off_shell = 2
 phs_t_channel = 6
 phs_e_scale =  1.000000000000E+01
 phs_m_scale =  1.000000000000E+01
 phs_q_scale =  1.000000000000E+01
 ?phs_keep_nonresonant = true
 ?phs_step_mapping = true
 ?phs_step_mapping_exp = true
 ?phs_s_mapping = true
 ?vis_history = false
 n_bins = 20
 ?normalize_bins = false
 $obs_label = ""
 $obs_unit = ""
 $title = ""
 $description = ""
 $x_label = ""
 $y_label = ""
 graph_width_mm = 130
 graph_height_mm = 90
 ?y_log = false
 ?x_log = false
 [undefined] x_min = [unknown real]
 [undefined] x_max = [unknown real]
 [undefined] y_min = [unknown real]
 [undefined] y_max = [unknown real]
 $gmlcode_bg = ""
 $gmlcode_fg = ""
 [undefined] ?draw_histogram = [unknown logical]
 [undefined] ?draw_base = [unknown logical]
 [undefined] ?draw_piecewise = [unknown logical]
 [undefined] ?fill_curve = [unknown logical]
 [undefined] ?draw_curve = [unknown logical]
 [undefined] ?draw_errors = [unknown logical]
 [undefined] ?draw_symbols = [unknown logical]
 [undefined] $fill_options = [unknown string]
 [undefined] $draw_options = [unknown string]
 [undefined] $err_options = [unknown string]
 [undefined] $symbol = [unknown string]
 ?analysis_file_only = false
 kt_algorithm* = 0
 cambridge_algorithm* = 1
 antikt_algorithm* = 2
 genkt_algorithm* = 3
 cambridge_for_passive_algorithm* = 11
 genkt_for_passive_algorithm* = 13
 ee_kt_algorithm* = 50
 ee_genkt_algorithm* = 53
 plugin_algorithm* = 99
 undefined_jet_algorithm* = 999
 jet_algorithm = 999
 jet_r =  0.000000000000E+00
 jet_p =  0.000000000000E+00
 jet_ycut =  0.000000000000E+00
 ?keep_flavors_when_clustering = false
 $sample = ""
 $sample_normalization = "auto"
 ?sample_pacify = false
 ?sample_select = true
 sample_max_tries = 10000
 sample_split_n_evt = 0
 sample_split_n_kbytes = 0
 sample_split_index = 0
 $rescan_input_format = "raw"
 ?read_raw = true
 ?write_raw = true
 $extension_raw = "evx"
 $extension_default = "evt"
 $debug_extension = "debug"
 ?debug_process = true
 ?debug_transforms = true
 ?debug_decay = true
 ?debug_verbose = true
 $dump_extension = "pset.dat"
 ?dump_compressed = false
 ?dump_weights = false
 ?dump_summary = false
 ?dump_screen = false
 ?hepevt_ensure_order = false
 $extension_hepevt = "hepevt"
 $extension_ascii_short = "short.evt"
 $extension_ascii_long = "long.evt"
 $extension_athena = "athena.evt"
 $extension_mokka = "mokka.evt"
 $lhef_version = "2.0"
 $lhef_extension = "lhe"
 ?lhef_write_sqme_prc = true
 ?lhef_write_sqme_ref = false
 ?lhef_write_sqme_alt = true
 $extension_lha = "lha"
 $extension_hepmc = "hepmc"
 ?hepmc_output_cross_section = false
 $extension_lcio = "slcio"
 $extension_stdhep = "hep"
 $extension_stdhep_up = "up.hep"
 $extension_stdhep_ev4 = "ev4.hep"
 $extension_hepevt_verb = "hepevt.verb"
 $extension_lha_verb = "lha.verb"
 ?allow_shower = true
 ?ps_fsr_active = false
 ?ps_isr_active = false
 ?ps_taudec_active = false
 ?muli_active = false
 $shower_method = "WHIZARD"
 ?shower_verbose = false
 $ps_PYTHIA_PYGIVE = ""
 ps_mass_cutoff =  1.000000000000E+00
 ps_fsr_lambda =  2.900000000000E-01
 ps_isr_lambda =  2.900000000000E-01
 ps_max_n_flavors = 5
 ?ps_isr_alphas_running = true
 ?ps_fsr_alphas_running = true
 ps_fixed_alphas =  0.000000000000E+00
 ?ps_isr_pt_ordered = false
 ?ps_isr_angular_ordered = true
 ps_isr_primordial_kt_width =  0.000000000000E+00
 ps_isr_primordial_kt_cutoff =  5.000000000000E+00
 ps_isr_z_cutoff =  9.990000000000E-01
 ps_isr_minenergy =  1.000000000000E+00
 ps_isr_tscalefactor =  1.000000000000E+00
 ?ps_isr_only_onshell_emitted_partons = false
 ?allow_hadronization = true
 ?hadronization_active = false
 $hadronization_method = "PYTHIA6"
 hadron_enhanced_fraction =  1.000000000000E-02
 hadron_enhanced_width =  2.000000000000E+00
 ?ps_tauola_photos = false
 ?ps_tauola_transverse = false
 ?ps_tauola_dec_rad_cor = true
 ps_tauola_dec_mode1 = 0
 ps_tauola_dec_mode2 = 0
 ps_tauola_mh =  1.250000000000E+02
 ps_tauola_mix_angle =  9.000000000000E+01
 ?ps_tauola_pol_vector = false
 ?mlm_matching = false
 mlm_Qcut_ME =  0.000000000000E+00
 mlm_Qcut_PS =  0.000000000000E+00
 mlm_ptmin =  0.000000000000E+00
 mlm_etamax =  0.000000000000E+00
 mlm_Rmin =  0.000000000000E+00
 mlm_Emin =  0.000000000000E+00
 mlm_nmaxMEjets = 0
 mlm_ETclusfactor =  2.000000000000E-01
 mlm_ETclusminE =  5.000000000000E+00
 mlm_etaclusfactor =  1.000000000000E+00
 mlm_Rclusfactor =  1.000000000000E+00
 mlm_Eclusfactor =  1.000000000000E+00
 ?powheg_matching = false
 ?powheg_use_singular_jacobian = false
 powheg_grid_size_xi = 5
 powheg_grid_size_y = 5
 powheg_grid_sampling_points = 500000
 powheg_pt_min =  1.000000000000E+00
 powheg_lambda =  2.000000000000E-01
 ?powheg_rebuild_grids = false
 ?powheg_test_sudakov = false
 ?powheg_disable_sudakov = false
 ?ckkw_matching = false
 ?omega_openmp = false
 ?openmp_is_active* = false
 openmp_num_threads_default* = 1
 openmp_num_threads = 1
 ?openmp_logging = true
 ?mpi_logging = false
 $born_me_method = ""
 $loop_me_method = ""
 $correlation_me_method = ""
 $real_tree_me_method = ""
 $dglap_me_method = ""
 ?test_soft_limit = false
 ?test_coll_limit = false
 ?test_anti_coll_limit = false
 $select_alpha_regions = ""
 $virtual_selection = "Full"
 ?virtual_collinear_resonance_aware = true
 blha_top_yukawa = -1.000000000000E+00
 $blha_ew_scheme = "alpha_qed"
 openloops_verbosity = 1
 ?openloops_use_cms = true
 openloops_phs_tolerance = 7
 openloops_stability_log = 0
 ?openloops_switch_off_muon_yukawa = false
 $openloops_extra_cmd = ""
 ?openloops_use_collier = true
 ?disable_subtraction = false
 fks_dij_exp1 =  1.000000000000E+00
 fks_dij_exp2 =  1.000000000000E+00
 fks_xi_min =  1.000000000000E-07
 fks_y_max =  1.000000000000E+00
 ?vis_fks_regions = false
 fks_xi_cut =  1.000000000000E+00
 fks_delta_zero =  2.000000000000E+00
 fks_delta_i =  2.000000000000E+00
 $fks_mapping_type = "default"
 $resonances_exclude_particles = "default"
 alpha_power = 2
 alphas_power = 0
 ?combined_nlo_integration = false
 ?fixed_order_nlo_events = false
 ?check_event_weights_against_xsection = false
 ?keep_failed_events = false
 gks_multiplicity = 0
 $gosam_filter_lo = ""
 $gosam_filter_nlo = ""
 $gosam_symmetries = "family,generation"
 form_threads = 2
 form_workspace = 1000
 $gosam_fc = ""
 mult_call_real =  1.000000000000E+00
 mult_call_virt =  1.000000000000E+00
 mult_call_dglap =  1.000000000000E+00
 $dalitz_plot = ""
 $nlo_correction_type = "QCD"
 $exclude_gauge_splittings = "c:b:t:e2:e3"
 ?nlo_use_born_scale = true
 ?nlo_cut_all_sqmes = true
 ?nlo_use_real_partition = false
 real_partition_scale =  1.000000000000E+01
 $fc => "Fortran-compiler"
 $fcflags => "Fortran-flags"
 ========================================================================
 model "Test"
  ! md5sum = 'DB28187ADA60804A3CFC14A025DED784'
 
    parameter gy =  1.000000000000E+00
    parameter ms =  1.250000000000E+02
    parameter ff =  1.500000000000E+00
    external mf =  1.875000000000E+02
 
    particle SCALAR 25
      name "s"
      spin 0
      mass ms
    particle FERMION 6
      name "f"
      anti "fbar" "F"
      tex_anti "\bar{f}"
      spin 1/2  isospin 1/2  charge 2/3  color 3
      mass mf
 
    vertex "fbar" "f" "s"
    vertex "s" "s" "s"
 ========================================================================
  Process library stack: [empty]
 ========================================================================
  Beam structure: [any particles]
 ========================================================================
  Cuts:
 ------------------------------------------------------------------------
 +  SEQUENCE    <lexpr>  =  <lsinglet>
 +  SEQUENCE    <lsinglet>  =  <lterm>
 |  +  SEQUENCE    <lterm>  =  <all_fun>
 |  |  +  SEQUENCE    <all_fun>  =  all <lexpr> <pargs1>
 |  |  |  +  KEYWORD     all  = [keyword] all
 |  |  |  +  SEQUENCE    <lexpr>  =  <lsinglet>
 |  |  |  |  +  SEQUENCE    <lsinglet>  =  <lterm>
 |  |  |  |  |  +  SEQUENCE    <lterm>  =  <compared_expr>
 |  |  |  |  |  |  +  SEQUENCE    <compared_expr>  =  <expr> <comparison>
 |  |  |  |  |  |  |  +  SEQUENCE    <expr>  =  <term>
 |  |  |  |  |  |  |  |  +  SEQUENCE    <term>  =  <factor>
 |  |  |  |  |  |  |  |  |  +  SEQUENCE    <factor>  =  <variable>
 |  |  |  |  |  |  |  |  |  |  +  IDENTIFIER  <variable>  = Pt
 |  |  |  |  |  |  |  +  SEQUENCE    <comparison>  =  '>' <expr>
 |  |  |  |  |  |  |  |  +  KEYWORD     '>'  = [keyword] >
 |  |  |  |  |  |  |  |  +  SEQUENCE    <expr>  =  <term>
 |  |  |  |  |  |  |  |  |  +  SEQUENCE    <term>  =  <factor>
 |  |  |  |  |  |  |  |  |  |  +  SEQUENCE    <factor>  =  <integer_value>
 |  |  |  |  |  |  |  |  |  |  |  +  SEQUENCE    <integer_value>  =  <integer_literal>
 |  |  |  |  |  |  |  |  |  |  |  |  +  INTEGER     <integer_literal>  = 100
 |  |  |  +  ARGUMENTS   <pargs1>  =  <pexpr>
 |  |  |  |  +  SEQUENCE    <pexpr>  =  <pterm>
 |  |  |  |  |  +  SEQUENCE    <pterm>  =  <pexpr_src>
 |  |  |  |  |  |  +  SEQUENCE    <pexpr_src>  =  <unspecified_prt>
 |  |  |  |  |  |  |  +  SEQUENCE    <unspecified_prt>  =  <cexpr>
 |  |  |  |  |  |  |  |  +  SEQUENCE    <cexpr>  =  <variable>
 |  |  |  |  |  |  |  |  |  +  IDENTIFIER  <variable>  = s
 ------------------------------------------------------------------------
  Scale: [undefined]
 ------------------------------------------------------------------------
  Factorization scale: [undefined]
 ------------------------------------------------------------------------
  Renormalization scale: [undefined]
 ------------------------------------------------------------------------
  Weight: [undefined]
 ========================================================================
  Event selection: [undefined]
 ------------------------------------------------------------------------
  Event reweighting factor: [undefined]
 ------------------------------------------------------------------------
  Event analysis: [undefined]
 ------------------------------------------------------------------------
  Event sample formats = foo_fmt, bar_fmt
 ------------------------------------------------------------------------
  Event callback: [undefined]
 ========================================================================
  Process stack: [empty]
 ========================================================================
  quit     : F
  quit_code: 0
 ========================================================================
  Logfile  : ''
 ========================================================================
 
 * Test output end: rt_data_2
Index: trunk/share/tests/unit_tests/ref-output/rt_data_3.ref
===================================================================
--- trunk/share/tests/unit_tests/ref-output/rt_data_3.ref	(revision 8163)
+++ trunk/share/tests/unit_tests/ref-output/rt_data_3.ref	(revision 8164)
@@ -1,1013 +1,1015 @@
 * Test output: rt_data_3
 *   Purpose: initialize global runtime data and fill contents;
 *            copy to local block and back
 
 * Init global data
 
 * Init and modify local data
 
  model associated   = T
  library associated = T
 
 ========================================================================
  Runtime data:
 ========================================================================
 gy =>  1.000000000000E+00
 ms =>  1.500000000000E+02
 ff =>  1.500000000000E+00
 mf* =>  2.250000000000E+02
 particle* = PDG(0)
 SCALAR* = PDG(25)
 s* = PDG(25)
 FERMION* = PDG(6)
 f* = PDG(6)
 fbar* = PDG(-6)
 F* = PDG(-6)
 charged* = PDG(6, -6)
 neutral* = PDG(25)
 colored* = PDG(6, -6)
 $model_name = "Test"
 $fc => "Local compiler"
 $fcflags => "Fortran-flags"
 $integration_method = "midpoint"
 $phs_method = "single"
 $library_name = "library_2"
 sqrts =  1.000000000000E+03
 luminosity =  3.300000000000E+01
 ?sf_trace = false
 $sf_trace_file = ""
 ?sf_allow_s_mapping = true
 $lhapdf_dir = ""
 $lhapdf_file = ""
 $lhapdf_photon_file = ""
 lhapdf_member = 0
 lhapdf_photon_scheme = 0
 $pdf_builtin_set = "CTEQ6L"
 ?hoppet_b_matching = false
 isr_alpha =  0.000000000000E+00
 isr_q_max =  0.000000000000E+00
 isr_mass =  0.000000000000E+00
 isr_order = 3
 ?isr_recoil = false
 ?isr_keep_energy = false
 ?isr_handler = false
 $isr_handler_mode = "trivial"
 epa_alpha =  0.000000000000E+00
 epa_x_min =  0.000000000000E+00
 epa_q_min =  0.000000000000E+00
 epa_q_max =  0.000000000000E+00
 epa_mass =  0.000000000000E+00
 ?epa_recoil = false
 ?epa_keep_energy = false
 ?epa_handler = false
 $epa_handler_mode = "trivial"
 ewa_x_min =  0.000000000000E+00
 ewa_pt_max =  0.000000000000E+00
 ewa_mass =  0.000000000000E+00
 ?ewa_recoil = false
 ?ewa_keep_energy = false
 ?circe1_photon1 = false
 ?circe1_photon2 = false
 [undefined] circe1_sqrts = [unknown real]
 ?circe1_generate = true
 ?circe1_map = true
 circe1_mapping_slope =  2.000000000000E+00
 circe1_eps =  1.000000000000E-05
 circe1_ver = 0
 circe1_rev = 0
 $circe1_acc = "SBAND"
 circe1_chat = 0
 ?circe1_with_radiation = false
 ?circe2_polarized = true
 [undefined] $circe2_file = [unknown string]
 $circe2_design = "*"
 gaussian_spread1 =  0.000000000000E+00
 gaussian_spread2 =  0.000000000000E+00
 [undefined] $beam_events_file = [unknown string]
 ?beam_events_warn_eof = true
 ?energy_scan_normalize = false
 ?logging => false
 [undefined] $job_id = [unknown string]
 [undefined] $compile_workspace = [unknown string]
 seed = 0
 $model_name = "Test"
 [undefined] process_num_id = [unknown integer]
 $method = "omega"
 ?report_progress = true
 [user variable] ?me_verbose = false
 $restrictions = ""
 ?omega_write_phs_output = false
 $omega_flags = ""
 ?read_color_factors = true
 ?slha_read_input = true
 ?slha_read_spectrum = true
 ?slha_read_decays = false
 $library_name = "library_1"
 ?alphas_is_fixed = true
 ?alphas_from_lhapdf = false
 ?alphas_from_pdf_builtin = false
 alphas_order = 0
 alphas_nf = 5
 ?alphas_from_mz = false
 ?alphas_from_lambda_qcd = false
 lambda_qcd =  2.000000000000E-01
 ?fatal_beam_decay = true
 ?helicity_selection_active = true
 helicity_selection_threshold =  1.000000000000E+10
 helicity_selection_cutoff = 1000
 $rng_method = "tao"
 ?vis_diags = false
 ?vis_diags_color = false
 ?check_event_file = true
 $event_file_version = ""
 n_events = 0
 event_index_offset = 0
 ?unweighted = true
 safety_factor =  1.000000000000E+00
 ?negative_weights = false
 ?resonance_history = false
 resonance_on_shell_limit =  4.000000000000E+00
 resonance_on_shell_turnoff =  0.000000000000E+00
 resonance_background_factor =  1.000000000000E+00
 ?keep_beams = false
 ?keep_remnants = true
 ?recover_beams = true
 ?update_event = false
 ?update_sqme = false
 ?update_weight = false
 ?use_alphas_from_file = false
 ?use_scale_from_file = false
 ?allow_decays = true
 ?auto_decays = false
 auto_decays_multiplicity = 2
 ?auto_decays_radiative = false
 ?decay_rest_frame = false
 ?isotropic_decay = false
 ?diagonal_decay = false
 [undefined] decay_helicity = [unknown integer]
 ?polarized_events = false
 $polarization_mode = "helicity"
+?colorize_subevt = false
 tolerance =  0.000000000000E+00
 checkpoint = 0
 event_callback_interval = 0
 ?pacify = false
 $out_file = ""
 ?out_advance = true
 real_range* = 307
 real_precision* = 15
 real_epsilon* =  1.000000000000E-16
 real_tiny* =  1.000000000000-300
 $integration_method = "vamp"
 threshold_calls = 10
 min_calls_per_channel = 10
 min_calls_per_bin = 10
 min_bins = 3
 max_bins = 20
 ?stratified = true
 ?use_vamp_equivalences = true
 ?vamp_verbose = false
 ?vamp_history_global = true
 ?vamp_history_global_verbose = false
 ?vamp_history_channels = false
 ?vamp_history_channels_verbose = false
 $run_id = "run1"
 n_calls_test = 0
 ?integration_timer = true
 ?check_grid_file = true
 accuracy_goal =  0.000000000000E+00
 error_goal =  0.000000000000E+00
 relative_error_goal =  0.000000000000E+00
 integration_results_verbosity = 1
 error_threshold =  0.000000000000E+00
 channel_weights_power =  2.500000000000E-01
 [undefined] $integrate_workspace = [unknown string]
 $phs_method = "default"
 ?vis_channels = false
 ?check_phs_file = true
 $phs_file = ""
 ?phs_only = false
 phs_threshold_s =  5.000000000000E+01
 phs_threshold_t =  1.000000000000E+02
 phs_off_shell = 2
 phs_t_channel = 6
 phs_e_scale =  1.000000000000E+01
 phs_m_scale =  1.000000000000E+01
 phs_q_scale =  1.000000000000E+01
 ?phs_keep_nonresonant = true
 ?phs_step_mapping = true
 ?phs_step_mapping_exp = true
 ?phs_s_mapping = true
 ?vis_history = false
 n_bins = 20
 ?normalize_bins = false
 $obs_label = ""
 $obs_unit = ""
 $title = ""
 $description = ""
 $x_label = ""
 $y_label = ""
 graph_width_mm = 130
 graph_height_mm = 90
 ?y_log = false
 ?x_log = false
 [undefined] x_min = [unknown real]
 [undefined] x_max = [unknown real]
 [undefined] y_min = [unknown real]
 [undefined] y_max = [unknown real]
 $gmlcode_bg = ""
 $gmlcode_fg = ""
 [undefined] ?draw_histogram = [unknown logical]
 [undefined] ?draw_base = [unknown logical]
 [undefined] ?draw_piecewise = [unknown logical]
 [undefined] ?fill_curve = [unknown logical]
 [undefined] ?draw_curve = [unknown logical]
 [undefined] ?draw_errors = [unknown logical]
 [undefined] ?draw_symbols = [unknown logical]
 [undefined] $fill_options = [unknown string]
 [undefined] $draw_options = [unknown string]
 [undefined] $err_options = [unknown string]
 [undefined] $symbol = [unknown string]
 ?analysis_file_only = false
 kt_algorithm* = 0
 cambridge_algorithm* = 1
 antikt_algorithm* = 2
 genkt_algorithm* = 3
 cambridge_for_passive_algorithm* = 11
 genkt_for_passive_algorithm* = 13
 ee_kt_algorithm* = 50
 ee_genkt_algorithm* = 53
 plugin_algorithm* = 99
 undefined_jet_algorithm* = 999
 jet_algorithm = 999
 jet_r =  0.000000000000E+00
 jet_p =  0.000000000000E+00
 jet_ycut =  0.000000000000E+00
 ?keep_flavors_when_clustering = false
 $sample = ""
 $sample_normalization = "auto"
 ?sample_pacify = false
 ?sample_select = true
 sample_max_tries = 10000
 sample_split_n_evt = 0
 sample_split_n_kbytes = 0
 sample_split_index = 0
 $rescan_input_format = "raw"
 ?read_raw = true
 ?write_raw = true
 $extension_raw = "evx"
 $extension_default = "evt"
 $debug_extension = "debug"
 ?debug_process = true
 ?debug_transforms = true
 ?debug_decay = true
 ?debug_verbose = true
 $dump_extension = "pset.dat"
 ?dump_compressed = false
 ?dump_weights = false
 ?dump_summary = false
 ?dump_screen = false
 ?hepevt_ensure_order = false
 $extension_hepevt = "hepevt"
 $extension_ascii_short = "short.evt"
 $extension_ascii_long = "long.evt"
 $extension_athena = "athena.evt"
 $extension_mokka = "mokka.evt"
 $lhef_version = "2.0"
 $lhef_extension = "lhe"
 ?lhef_write_sqme_prc = true
 ?lhef_write_sqme_ref = false
 ?lhef_write_sqme_alt = true
 $extension_lha = "lha"
 $extension_hepmc = "hepmc"
 ?hepmc_output_cross_section = false
 $extension_lcio = "slcio"
 $extension_stdhep = "hep"
 $extension_stdhep_up = "up.hep"
 $extension_stdhep_ev4 = "ev4.hep"
 $extension_hepevt_verb = "hepevt.verb"
 $extension_lha_verb = "lha.verb"
 ?allow_shower = true
 ?ps_fsr_active = false
 ?ps_isr_active = false
 ?ps_taudec_active = false
 ?muli_active = false
 $shower_method = "WHIZARD"
 ?shower_verbose = false
 $ps_PYTHIA_PYGIVE = ""
 ps_mass_cutoff =  1.000000000000E+00
 ps_fsr_lambda =  2.900000000000E-01
 ps_isr_lambda =  2.900000000000E-01
 ps_max_n_flavors = 5
 ?ps_isr_alphas_running = true
 ?ps_fsr_alphas_running = true
 ps_fixed_alphas =  0.000000000000E+00
 ?ps_isr_pt_ordered = false
 ?ps_isr_angular_ordered = true
 ps_isr_primordial_kt_width =  0.000000000000E+00
 ps_isr_primordial_kt_cutoff =  5.000000000000E+00
 ps_isr_z_cutoff =  9.990000000000E-01
 ps_isr_minenergy =  1.000000000000E+00
 ps_isr_tscalefactor =  1.000000000000E+00
 ?ps_isr_only_onshell_emitted_partons = false
 ?allow_hadronization = true
 ?hadronization_active = false
 $hadronization_method = "PYTHIA6"
 hadron_enhanced_fraction =  1.000000000000E-02
 hadron_enhanced_width =  2.000000000000E+00
 ?ps_tauola_photos = false
 ?ps_tauola_transverse = false
 ?ps_tauola_dec_rad_cor = true
 ps_tauola_dec_mode1 = 0
 ps_tauola_dec_mode2 = 0
 ps_tauola_mh =  1.250000000000E+02
 ps_tauola_mix_angle =  9.000000000000E+01
 ?ps_tauola_pol_vector = false
 ?mlm_matching = false
 mlm_Qcut_ME =  0.000000000000E+00
 mlm_Qcut_PS =  0.000000000000E+00
 mlm_ptmin =  0.000000000000E+00
 mlm_etamax =  0.000000000000E+00
 mlm_Rmin =  0.000000000000E+00
 mlm_Emin =  0.000000000000E+00
 mlm_nmaxMEjets = 0
 mlm_ETclusfactor =  2.000000000000E-01
 mlm_ETclusminE =  5.000000000000E+00
 mlm_etaclusfactor =  1.000000000000E+00
 mlm_Rclusfactor =  1.000000000000E+00
 mlm_Eclusfactor =  1.000000000000E+00
 ?powheg_matching = false
 ?powheg_use_singular_jacobian = false
 powheg_grid_size_xi = 5
 powheg_grid_size_y = 5
 powheg_grid_sampling_points = 500000
 powheg_pt_min =  1.000000000000E+00
 powheg_lambda =  2.000000000000E-01
 ?powheg_rebuild_grids = false
 ?powheg_test_sudakov = false
 ?powheg_disable_sudakov = false
 ?ckkw_matching = false
 ?omega_openmp = false
 ?openmp_is_active* = false
 openmp_num_threads_default* = 1
 openmp_num_threads = 1
 ?openmp_logging = true
 ?mpi_logging = false
 $born_me_method = ""
 $loop_me_method = ""
 $correlation_me_method = ""
 $real_tree_me_method = ""
 $dglap_me_method = ""
 ?test_soft_limit = false
 ?test_coll_limit = false
 ?test_anti_coll_limit = false
 $select_alpha_regions = ""
 $virtual_selection = "Full"
 ?virtual_collinear_resonance_aware = true
 blha_top_yukawa = -1.000000000000E+00
 $blha_ew_scheme = "alpha_qed"
 openloops_verbosity = 1
 ?openloops_use_cms = true
 openloops_phs_tolerance = 7
 openloops_stability_log = 0
 ?openloops_switch_off_muon_yukawa = false
 $openloops_extra_cmd = ""
 ?openloops_use_collier = true
 ?disable_subtraction = false
 fks_dij_exp1 =  1.000000000000E+00
 fks_dij_exp2 =  1.000000000000E+00
 fks_xi_min =  1.000000000000E-07
 fks_y_max =  1.000000000000E+00
 ?vis_fks_regions = false
 fks_xi_cut =  1.000000000000E+00
 fks_delta_zero =  2.000000000000E+00
 fks_delta_i =  2.000000000000E+00
 $fks_mapping_type = "default"
 $resonances_exclude_particles = "default"
 alpha_power = 2
 alphas_power = 0
 ?combined_nlo_integration = false
 ?fixed_order_nlo_events = false
 ?check_event_weights_against_xsection = false
 ?keep_failed_events = false
 gks_multiplicity = 0
 $gosam_filter_lo = ""
 $gosam_filter_nlo = ""
 $gosam_symmetries = "family,generation"
 form_threads = 2
 form_workspace = 1000
 $gosam_fc = ""
 mult_call_real =  1.000000000000E+00
 mult_call_virt =  1.000000000000E+00
 mult_call_dglap =  1.000000000000E+00
 $dalitz_plot = ""
 $nlo_correction_type = "QCD"
 $exclude_gauge_splittings = "c:b:t:e2:e3"
 ?nlo_use_born_scale = true
 ?nlo_cut_all_sqmes = true
 ?nlo_use_real_partition = false
 real_partition_scale =  1.000000000000E+01
 $fc => "Fortran-compiler"
 $fcflags => "Fortran-flags"
 ========================================================================
 model "Test"
  ! md5sum = 'DB28187ADA60804A3CFC14A025DED784'
 
    parameter gy =  1.000000000000E+00
    parameter ms =  1.500000000000E+02
    parameter ff =  1.500000000000E+00
    external mf =  2.250000000000E+02
 
    particle SCALAR 25
      name "s"
      spin 0
      mass ms
    particle FERMION 6
      name "f"
      anti "fbar" "F"
      tex_anti "\bar{f}"
      spin 1/2  isospin 1/2  charge 2/3  color 3
      mass mf
 
    vertex "fbar" "f" "s"
    vertex "s" "s" "s"
 ========================================================================
  Process library stack:
 ------------------------------------------------------------------------
  Process library: library_2
    external        = F
    makefile exists = F
    driver exists   = F
    code status     = o
 
  Process definition list: [empty]
 ------------------------------------------------------------------------
  Process library: library_1
    external        = F
    makefile exists = F
    driver exists   = F
    code status     = o
 
  Process definition list: [empty]
 ========================================================================
  Beam structure: s, s => pdf_builtin
 ========================================================================
  Cuts:
 ------------------------------------------------------------------------
 +  SEQUENCE    <lexpr>  =  <lsinglet>
 +  SEQUENCE    <lsinglet>  =  <lterm>
 |  +  SEQUENCE    <lterm>  =  <all_fun>
 |  |  +  SEQUENCE    <all_fun>  =  all <lexpr> <pargs1>
 |  |  |  +  KEYWORD     all  = [keyword] all
 |  |  |  +  SEQUENCE    <lexpr>  =  <lsinglet>
 |  |  |  |  +  SEQUENCE    <lsinglet>  =  <lterm>
 |  |  |  |  |  +  SEQUENCE    <lterm>  =  <compared_expr>
 |  |  |  |  |  |  +  SEQUENCE    <compared_expr>  =  <expr> <comparison>
 |  |  |  |  |  |  |  +  SEQUENCE    <expr>  =  <term>
 |  |  |  |  |  |  |  |  +  SEQUENCE    <term>  =  <factor>
 |  |  |  |  |  |  |  |  |  +  SEQUENCE    <factor>  =  <variable>
 |  |  |  |  |  |  |  |  |  |  +  IDENTIFIER  <variable>  = Pt
 |  |  |  |  |  |  |  +  SEQUENCE    <comparison>  =  '>' <expr>
 |  |  |  |  |  |  |  |  +  KEYWORD     '>'  = [keyword] >
 |  |  |  |  |  |  |  |  +  SEQUENCE    <expr>  =  <term>
 |  |  |  |  |  |  |  |  |  +  SEQUENCE    <term>  =  <factor>
 |  |  |  |  |  |  |  |  |  |  +  SEQUENCE    <factor>  =  <integer_value>
 |  |  |  |  |  |  |  |  |  |  |  +  SEQUENCE    <integer_value>  =  <integer_literal>
 |  |  |  |  |  |  |  |  |  |  |  |  +  INTEGER     <integer_literal>  = 100
 |  |  |  +  ARGUMENTS   <pargs1>  =  <pexpr>
 |  |  |  |  +  SEQUENCE    <pexpr>  =  <pterm>
 |  |  |  |  |  +  SEQUENCE    <pterm>  =  <pexpr_src>
 |  |  |  |  |  |  +  SEQUENCE    <pexpr_src>  =  <unspecified_prt>
 |  |  |  |  |  |  |  +  SEQUENCE    <unspecified_prt>  =  <cexpr>
 |  |  |  |  |  |  |  |  +  SEQUENCE    <cexpr>  =  <variable>
 |  |  |  |  |  |  |  |  |  +  IDENTIFIER  <variable>  = s
 ------------------------------------------------------------------------
  Scale: [undefined]
 ------------------------------------------------------------------------
  Factorization scale: [undefined]
 ------------------------------------------------------------------------
  Renormalization scale: [undefined]
 ------------------------------------------------------------------------
  Weight: [undefined]
 ========================================================================
  Event selection: [undefined]
 ------------------------------------------------------------------------
  Event reweighting factor: [undefined]
 ------------------------------------------------------------------------
  Event analysis: [undefined]
 ------------------------------------------------------------------------
  Event sample formats = foo_fmt, bar_fmt
 ------------------------------------------------------------------------
  Event callback: NOP
 ========================================================================
  Process stack: [empty]
 ========================================================================
  [Processes from context environment:]
 ========================================================================
  Process stack: [empty]
 ========================================================================
  quit     : F
  quit_code: 0
 ========================================================================
  Logfile  : ''
 ========================================================================
 
 * Restore global data
 
  model associated   = T
  library associated = T
 
 ========================================================================
  Runtime data:
 ========================================================================
 gy =>  1.000000000000E+00
 ms =>  1.250000000000E+02
 ff =>  1.500000000000E+00
 mf* =>  1.875000000000E+02
 particle* = PDG(0)
 SCALAR* = PDG(25)
 s* = PDG(25)
 FERMION* = PDG(6)
 f* = PDG(6)
 fbar* = PDG(-6)
 F* = PDG(-6)
 charged* = PDG(6, -6)
 neutral* = PDG(25)
 colored* = PDG(6, -6)
 sqrts =  1.000000000000E+03
 luminosity =  3.300000000000E+01
 ?sf_trace = false
 $sf_trace_file = ""
 ?sf_allow_s_mapping = true
 $lhapdf_dir = ""
 $lhapdf_file = ""
 $lhapdf_photon_file = ""
 lhapdf_member = 0
 lhapdf_photon_scheme = 0
 $pdf_builtin_set = "CTEQ6L"
 ?hoppet_b_matching = false
 isr_alpha =  0.000000000000E+00
 isr_q_max =  0.000000000000E+00
 isr_mass =  0.000000000000E+00
 isr_order = 3
 ?isr_recoil = false
 ?isr_keep_energy = false
 ?isr_handler = false
 $isr_handler_mode = "trivial"
 epa_alpha =  0.000000000000E+00
 epa_x_min =  0.000000000000E+00
 epa_q_min =  0.000000000000E+00
 epa_q_max =  0.000000000000E+00
 epa_mass =  0.000000000000E+00
 ?epa_recoil = false
 ?epa_keep_energy = false
 ?epa_handler = false
 $epa_handler_mode = "trivial"
 ewa_x_min =  0.000000000000E+00
 ewa_pt_max =  0.000000000000E+00
 ewa_mass =  0.000000000000E+00
 ?ewa_recoil = false
 ?ewa_keep_energy = false
 ?circe1_photon1 = false
 ?circe1_photon2 = false
 [undefined] circe1_sqrts = [unknown real]
 ?circe1_generate = true
 ?circe1_map = true
 circe1_mapping_slope =  2.000000000000E+00
 circe1_eps =  1.000000000000E-05
 circe1_ver = 0
 circe1_rev = 0
 $circe1_acc = "SBAND"
 circe1_chat = 0
 ?circe1_with_radiation = false
 ?circe2_polarized = true
 [undefined] $circe2_file = [unknown string]
 $circe2_design = "*"
 gaussian_spread1 =  0.000000000000E+00
 gaussian_spread2 =  0.000000000000E+00
 [undefined] $beam_events_file = [unknown string]
 ?beam_events_warn_eof = true
 ?energy_scan_normalize = false
 ?logging => false
 [undefined] $job_id = [unknown string]
 [undefined] $compile_workspace = [unknown string]
 seed = 0
 $model_name = "Test"
 [undefined] process_num_id = [unknown integer]
 $method = "omega"
 ?report_progress = true
 [user variable] ?me_verbose = false
 $restrictions = ""
 ?omega_write_phs_output = false
 $omega_flags = ""
 ?read_color_factors = true
 ?slha_read_input = true
 ?slha_read_spectrum = true
 ?slha_read_decays = false
 $library_name = "library_1"
 ?alphas_is_fixed = true
 ?alphas_from_lhapdf = false
 ?alphas_from_pdf_builtin = false
 alphas_order = 0
 alphas_nf = 5
 ?alphas_from_mz = false
 ?alphas_from_lambda_qcd = false
 lambda_qcd =  2.000000000000E-01
 ?fatal_beam_decay = true
 ?helicity_selection_active = true
 helicity_selection_threshold =  1.000000000000E+10
 helicity_selection_cutoff = 1000
 $rng_method = "tao"
 ?vis_diags = false
 ?vis_diags_color = false
 ?check_event_file = true
 $event_file_version = ""
 n_events = 0
 event_index_offset = 0
 ?unweighted = true
 safety_factor =  1.000000000000E+00
 ?negative_weights = false
 ?resonance_history = false
 resonance_on_shell_limit =  4.000000000000E+00
 resonance_on_shell_turnoff =  0.000000000000E+00
 resonance_background_factor =  1.000000000000E+00
 ?keep_beams = false
 ?keep_remnants = true
 ?recover_beams = true
 ?update_event = false
 ?update_sqme = false
 ?update_weight = false
 ?use_alphas_from_file = false
 ?use_scale_from_file = false
 ?allow_decays = true
 ?auto_decays = false
 auto_decays_multiplicity = 2
 ?auto_decays_radiative = false
 ?decay_rest_frame = false
 ?isotropic_decay = false
 ?diagonal_decay = false
 [undefined] decay_helicity = [unknown integer]
 ?polarized_events = false
 $polarization_mode = "helicity"
+?colorize_subevt = false
 tolerance =  0.000000000000E+00
 checkpoint = 0
 event_callback_interval = 0
 ?pacify = false
 $out_file = ""
 ?out_advance = true
 real_range* = 307
 real_precision* = 15
 real_epsilon* =  1.000000000000E-16
 real_tiny* =  1.000000000000-300
 $integration_method = "vamp"
 threshold_calls = 10
 min_calls_per_channel = 10
 min_calls_per_bin = 10
 min_bins = 3
 max_bins = 20
 ?stratified = true
 ?use_vamp_equivalences = true
 ?vamp_verbose = false
 ?vamp_history_global = true
 ?vamp_history_global_verbose = false
 ?vamp_history_channels = false
 ?vamp_history_channels_verbose = false
 $run_id = "run1"
 n_calls_test = 0
 ?integration_timer = true
 ?check_grid_file = true
 accuracy_goal =  0.000000000000E+00
 error_goal =  0.000000000000E+00
 relative_error_goal =  0.000000000000E+00
 integration_results_verbosity = 1
 error_threshold =  0.000000000000E+00
 channel_weights_power =  2.500000000000E-01
 [undefined] $integrate_workspace = [unknown string]
 $phs_method = "default"
 ?vis_channels = false
 ?check_phs_file = true
 $phs_file = ""
 ?phs_only = false
 phs_threshold_s =  5.000000000000E+01
 phs_threshold_t =  1.000000000000E+02
 phs_off_shell = 2
 phs_t_channel = 6
 phs_e_scale =  1.000000000000E+01
 phs_m_scale =  1.000000000000E+01
 phs_q_scale =  1.000000000000E+01
 ?phs_keep_nonresonant = true
 ?phs_step_mapping = true
 ?phs_step_mapping_exp = true
 ?phs_s_mapping = true
 ?vis_history = false
 n_bins = 20
 ?normalize_bins = false
 $obs_label = ""
 $obs_unit = ""
 $title = ""
 $description = ""
 $x_label = ""
 $y_label = ""
 graph_width_mm = 130
 graph_height_mm = 90
 ?y_log = false
 ?x_log = false
 [undefined] x_min = [unknown real]
 [undefined] x_max = [unknown real]
 [undefined] y_min = [unknown real]
 [undefined] y_max = [unknown real]
 $gmlcode_bg = ""
 $gmlcode_fg = ""
 [undefined] ?draw_histogram = [unknown logical]
 [undefined] ?draw_base = [unknown logical]
 [undefined] ?draw_piecewise = [unknown logical]
 [undefined] ?fill_curve = [unknown logical]
 [undefined] ?draw_curve = [unknown logical]
 [undefined] ?draw_errors = [unknown logical]
 [undefined] ?draw_symbols = [unknown logical]
 [undefined] $fill_options = [unknown string]
 [undefined] $draw_options = [unknown string]
 [undefined] $err_options = [unknown string]
 [undefined] $symbol = [unknown string]
 ?analysis_file_only = false
 kt_algorithm* = 0
 cambridge_algorithm* = 1
 antikt_algorithm* = 2
 genkt_algorithm* = 3
 cambridge_for_passive_algorithm* = 11
 genkt_for_passive_algorithm* = 13
 ee_kt_algorithm* = 50
 ee_genkt_algorithm* = 53
 plugin_algorithm* = 99
 undefined_jet_algorithm* = 999
 jet_algorithm = 999
 jet_r =  0.000000000000E+00
 jet_p =  0.000000000000E+00
 jet_ycut =  0.000000000000E+00
 ?keep_flavors_when_clustering = false
 $sample = ""
 $sample_normalization = "auto"
 ?sample_pacify = false
 ?sample_select = true
 sample_max_tries = 10000
 sample_split_n_evt = 0
 sample_split_n_kbytes = 0
 sample_split_index = 0
 $rescan_input_format = "raw"
 ?read_raw = true
 ?write_raw = true
 $extension_raw = "evx"
 $extension_default = "evt"
 $debug_extension = "debug"
 ?debug_process = true
 ?debug_transforms = true
 ?debug_decay = true
 ?debug_verbose = true
 $dump_extension = "pset.dat"
 ?dump_compressed = false
 ?dump_weights = false
 ?dump_summary = false
 ?dump_screen = false
 ?hepevt_ensure_order = false
 $extension_hepevt = "hepevt"
 $extension_ascii_short = "short.evt"
 $extension_ascii_long = "long.evt"
 $extension_athena = "athena.evt"
 $extension_mokka = "mokka.evt"
 $lhef_version = "2.0"
 $lhef_extension = "lhe"
 ?lhef_write_sqme_prc = true
 ?lhef_write_sqme_ref = false
 ?lhef_write_sqme_alt = true
 $extension_lha = "lha"
 $extension_hepmc = "hepmc"
 ?hepmc_output_cross_section = false
 $extension_lcio = "slcio"
 $extension_stdhep = "hep"
 $extension_stdhep_up = "up.hep"
 $extension_stdhep_ev4 = "ev4.hep"
 $extension_hepevt_verb = "hepevt.verb"
 $extension_lha_verb = "lha.verb"
 ?allow_shower = true
 ?ps_fsr_active = false
 ?ps_isr_active = false
 ?ps_taudec_active = false
 ?muli_active = false
 $shower_method = "WHIZARD"
 ?shower_verbose = false
 $ps_PYTHIA_PYGIVE = ""
 ps_mass_cutoff =  1.000000000000E+00
 ps_fsr_lambda =  2.900000000000E-01
 ps_isr_lambda =  2.900000000000E-01
 ps_max_n_flavors = 5
 ?ps_isr_alphas_running = true
 ?ps_fsr_alphas_running = true
 ps_fixed_alphas =  0.000000000000E+00
 ?ps_isr_pt_ordered = false
 ?ps_isr_angular_ordered = true
 ps_isr_primordial_kt_width =  0.000000000000E+00
 ps_isr_primordial_kt_cutoff =  5.000000000000E+00
 ps_isr_z_cutoff =  9.990000000000E-01
 ps_isr_minenergy =  1.000000000000E+00
 ps_isr_tscalefactor =  1.000000000000E+00
 ?ps_isr_only_onshell_emitted_partons = false
 ?allow_hadronization = true
 ?hadronization_active = false
 $hadronization_method = "PYTHIA6"
 hadron_enhanced_fraction =  1.000000000000E-02
 hadron_enhanced_width =  2.000000000000E+00
 ?ps_tauola_photos = false
 ?ps_tauola_transverse = false
 ?ps_tauola_dec_rad_cor = true
 ps_tauola_dec_mode1 = 0
 ps_tauola_dec_mode2 = 0
 ps_tauola_mh =  1.250000000000E+02
 ps_tauola_mix_angle =  9.000000000000E+01
 ?ps_tauola_pol_vector = false
 ?mlm_matching = false
 mlm_Qcut_ME =  0.000000000000E+00
 mlm_Qcut_PS =  0.000000000000E+00
 mlm_ptmin =  0.000000000000E+00
 mlm_etamax =  0.000000000000E+00
 mlm_Rmin =  0.000000000000E+00
 mlm_Emin =  0.000000000000E+00
 mlm_nmaxMEjets = 0
 mlm_ETclusfactor =  2.000000000000E-01
 mlm_ETclusminE =  5.000000000000E+00
 mlm_etaclusfactor =  1.000000000000E+00
 mlm_Rclusfactor =  1.000000000000E+00
 mlm_Eclusfactor =  1.000000000000E+00
 ?powheg_matching = false
 ?powheg_use_singular_jacobian = false
 powheg_grid_size_xi = 5
 powheg_grid_size_y = 5
 powheg_grid_sampling_points = 500000
 powheg_pt_min =  1.000000000000E+00
 powheg_lambda =  2.000000000000E-01
 ?powheg_rebuild_grids = false
 ?powheg_test_sudakov = false
 ?powheg_disable_sudakov = false
 ?ckkw_matching = false
 ?omega_openmp = false
 ?openmp_is_active* = false
 openmp_num_threads_default* = 1
 openmp_num_threads = 1
 ?openmp_logging = true
 ?mpi_logging = false
 $born_me_method = ""
 $loop_me_method = ""
 $correlation_me_method = ""
 $real_tree_me_method = ""
 $dglap_me_method = ""
 ?test_soft_limit = false
 ?test_coll_limit = false
 ?test_anti_coll_limit = false
 $select_alpha_regions = ""
 $virtual_selection = "Full"
 ?virtual_collinear_resonance_aware = true
 blha_top_yukawa = -1.000000000000E+00
 $blha_ew_scheme = "alpha_qed"
 openloops_verbosity = 1
 ?openloops_use_cms = true
 openloops_phs_tolerance = 7
 openloops_stability_log = 0
 ?openloops_switch_off_muon_yukawa = false
 $openloops_extra_cmd = ""
 ?openloops_use_collier = true
 ?disable_subtraction = false
 fks_dij_exp1 =  1.000000000000E+00
 fks_dij_exp2 =  1.000000000000E+00
 fks_xi_min =  1.000000000000E-07
 fks_y_max =  1.000000000000E+00
 ?vis_fks_regions = false
 fks_xi_cut =  1.000000000000E+00
 fks_delta_zero =  2.000000000000E+00
 fks_delta_i =  2.000000000000E+00
 $fks_mapping_type = "default"
 $resonances_exclude_particles = "default"
 alpha_power = 2
 alphas_power = 0
 ?combined_nlo_integration = false
 ?fixed_order_nlo_events = false
 ?check_event_weights_against_xsection = false
 ?keep_failed_events = false
 gks_multiplicity = 0
 $gosam_filter_lo = ""
 $gosam_filter_nlo = ""
 $gosam_symmetries = "family,generation"
 form_threads = 2
 form_workspace = 1000
 $gosam_fc = ""
 mult_call_real =  1.000000000000E+00
 mult_call_virt =  1.000000000000E+00
 mult_call_dglap =  1.000000000000E+00
 $dalitz_plot = ""
 $nlo_correction_type = "QCD"
 $exclude_gauge_splittings = "c:b:t:e2:e3"
 ?nlo_use_born_scale = true
 ?nlo_cut_all_sqmes = true
 ?nlo_use_real_partition = false
 real_partition_scale =  1.000000000000E+01
 $fc => "Fortran-compiler"
 $fcflags => "Fortran-flags"
 ========================================================================
 model "Test"
  ! md5sum = 'DB28187ADA60804A3CFC14A025DED784'
 
    parameter gy =  1.000000000000E+00
    parameter ms =  1.250000000000E+02
    parameter ff =  1.500000000000E+00
    external mf =  1.875000000000E+02
 
    particle SCALAR 25
      name "s"
      spin 0
      mass ms
    particle FERMION 6
      name "f"
      anti "fbar" "F"
      tex_anti "\bar{f}"
      spin 1/2  isospin 1/2  charge 2/3  color 3
      mass mf
 
    vertex "fbar" "f" "s"
    vertex "s" "s" "s"
 ========================================================================
  Process library stack:
 ------------------------------------------------------------------------
  Process library: library_2
    external        = F
    makefile exists = F
    driver exists   = F
    code status     = o
 
  Process definition list: [empty]
 ------------------------------------------------------------------------
  Process library: library_1
    external        = F
    makefile exists = F
    driver exists   = F
    code status     = o
 
  Process definition list: [empty]
 ========================================================================
  Beam structure: s, s => pdf_builtin
 ========================================================================
  Cuts:
 ------------------------------------------------------------------------
 +  SEQUENCE    <lexpr>  =  <lsinglet>
 +  SEQUENCE    <lsinglet>  =  <lterm>
 |  +  SEQUENCE    <lterm>  =  <all_fun>
 |  |  +  SEQUENCE    <all_fun>  =  all <lexpr> <pargs1>
 |  |  |  +  KEYWORD     all  = [keyword] all
 |  |  |  +  SEQUENCE    <lexpr>  =  <lsinglet>
 |  |  |  |  +  SEQUENCE    <lsinglet>  =  <lterm>
 |  |  |  |  |  +  SEQUENCE    <lterm>  =  <compared_expr>
 |  |  |  |  |  |  +  SEQUENCE    <compared_expr>  =  <expr> <comparison>
 |  |  |  |  |  |  |  +  SEQUENCE    <expr>  =  <term>
 |  |  |  |  |  |  |  |  +  SEQUENCE    <term>  =  <factor>
 |  |  |  |  |  |  |  |  |  +  SEQUENCE    <factor>  =  <variable>
 |  |  |  |  |  |  |  |  |  |  +  IDENTIFIER  <variable>  = Pt
 |  |  |  |  |  |  |  +  SEQUENCE    <comparison>  =  '>' <expr>
 |  |  |  |  |  |  |  |  +  KEYWORD     '>'  = [keyword] >
 |  |  |  |  |  |  |  |  +  SEQUENCE    <expr>  =  <term>
 |  |  |  |  |  |  |  |  |  +  SEQUENCE    <term>  =  <factor>
 |  |  |  |  |  |  |  |  |  |  +  SEQUENCE    <factor>  =  <integer_value>
 |  |  |  |  |  |  |  |  |  |  |  +  SEQUENCE    <integer_value>  =  <integer_literal>
 |  |  |  |  |  |  |  |  |  |  |  |  +  INTEGER     <integer_literal>  = 100
 |  |  |  +  ARGUMENTS   <pargs1>  =  <pexpr>
 |  |  |  |  +  SEQUENCE    <pexpr>  =  <pterm>
 |  |  |  |  |  +  SEQUENCE    <pterm>  =  <pexpr_src>
 |  |  |  |  |  |  +  SEQUENCE    <pexpr_src>  =  <unspecified_prt>
 |  |  |  |  |  |  |  +  SEQUENCE    <unspecified_prt>  =  <cexpr>
 |  |  |  |  |  |  |  |  +  SEQUENCE    <cexpr>  =  <variable>
 |  |  |  |  |  |  |  |  |  +  IDENTIFIER  <variable>  = s
 ------------------------------------------------------------------------
  Scale: [undefined]
 ------------------------------------------------------------------------
  Factorization scale: [undefined]
 ------------------------------------------------------------------------
  Renormalization scale: [undefined]
 ------------------------------------------------------------------------
  Weight: [undefined]
 ========================================================================
  Event selection: [undefined]
 ------------------------------------------------------------------------
  Event reweighting factor: [undefined]
 ------------------------------------------------------------------------
  Event analysis: [undefined]
 ------------------------------------------------------------------------
  Event sample formats = foo_fmt, bar_fmt
 ------------------------------------------------------------------------
  Event callback: [undefined]
 ========================================================================
  Process stack: [empty]
 ========================================================================
  quit     : F
  quit_code: 0
 ========================================================================
  Logfile  : ''
 ========================================================================
 
 * Cleanup
 
 * Test output end: rt_data_3
Index: trunk/share/tests/unit_tests/ref-output/expressions_1.ref
===================================================================
--- trunk/share/tests/unit_tests/ref-output/expressions_1.ref	(revision 8163)
+++ trunk/share/tests/unit_tests/ref-output/expressions_1.ref	(revision 8164)
@@ -1,32 +1,34 @@
 * Test output: Expressions
 *   Purpose: test simple observable and node evaluation
 
 * Setting a unary observable:
 
 PDG => [int] = unary observable
 Hel => [int] = unary observable
+Ncol => [int] = unary observable
+Nacl => [int] = unary observable
 M => [real] = unary observable
 M2 => [real] = unary observable
 E => [real] = unary observable
 Px => [real] = unary observable
 Py => [real] = unary observable
 Pz => [real] = unary observable
 P => [real] = unary observable
 Pl => [real] = unary observable
 Pt => [real] = unary observable
 Theta => [real] = unary observable
 Phi => [real] = unary observable
 Rap => [real] = unary observable
 Eta => [real] = unary observable
 Theta_star => [real] = unary observable
 Dist => [real] = unary observable
 _User_obs_real => [real] = unary user observable
 _User_obs_int => [int] = unary user observable
 * Evaluating the observable node:
 
 o PDG = [unknown integer]
       prt1 = prt(?)
 * Cleanup
 
 
 * Test output end: expressions_1
Index: trunk/share/tests/functional_tests/analyze_5.sin
===================================================================
--- trunk/share/tests/functional_tests/analyze_5.sin	(revision 0)
+++ trunk/share/tests/functional_tests/analyze_5.sin	(revision 8164)
@@ -0,0 +1,45 @@
+# SINDARIN input for WHIZARD self test
+
+model = QCD
+
+?logging = true
+?openmp_logging = false
+?vis_history = false
+?integration_timer = false
+?pacify = true
+
+seed = 0
+
+process analyze_5_p = u, ubar => u, ubar
+
+sqrts = 100
+cuts = all Pt > 10 [u:ubar]
+iterations = 1:1000
+
+sample_format = debug
+?sample_pacify = true
+?debug_process = false
+?debug_transforms = true
+$sample = "analyze_5"
+
+?colorize_subevt = true
+simulate (analyze_5_p) { 
+  n_events = 1
+}
+
+observable ncol
+observable nacl
+
+sample_format = dump
+simulate (analyze_5_p) {
+  n_events = 100
+  analysis = 
+    record ncol (eval real (Ncol) [collect [u:ubar]])
+    and
+    record nacl (eval real (Nacl) [collect [u:ubar]])
+}
+
+$out_file = "analyze_5.dat"
+write_analysis
+
+    
Index: trunk/share/tests/functional_tests/ref-output/process_log.ref
===================================================================
--- trunk/share/tests/functional_tests/ref-output/process_log.ref	(revision 8163)
+++ trunk/share/tests/functional_tests/ref-output/process_log.ref	(revision 8164)
@@ -1,538 +1,539 @@
 ###############################################################################
  Process [scattering]: 'process_log_1_p1'
    Run ID        = ''
    Library name  = 'process_log_lib'
    Process index = 1
    Process components:
      1: 'process_log_1_p1_i1':   e-, e+ => m-, m+ [omega]
 ------------------------------------------------------------------------
  Variable list: [not shown]
 ###############################################################################
    Integral   =  8.3556567814E+03
    Error      =  3.2359019246E+00
    Accuracy   =  1.8972317270E-02
    Chi2       =  5.2032955661E-01
    Efficiency =  7.8315602603E-01
    T(10k evt) =  <time estimate>
 |=============================================================================|
 | It      Calls  Integral[fb]  Error[fb]   Err[%]    Acc  Eff[%]   Chi2 N[It] |
 |=============================================================================|
    1        800  8.3525258E+03  6.97E+00    0.08    0.02*  67.98
    2        800  8.3688100E+03  5.46E+00    0.07    0.02*  59.78
    3        800  8.3686236E+03  5.53E+00    0.07    0.02   78.45
 |-----------------------------------------------------------------------------|
    3       2400  8.3648733E+03  3.39E+00    0.04    0.02   78.45    2.06   3
 |-----------------------------------------------------------------------------|
    4        800  8.3602554E+03  5.63E+00    0.07    0.02   78.37
    5        800  8.3525628E+03  5.62E+00    0.07    0.02   78.30
    6        800  8.3541861E+03  5.56E+00    0.07    0.02*  78.32
 |-----------------------------------------------------------------------------|
    6       2400  8.3556568E+03  3.24E+00    0.04    0.02   78.32    0.52   3
 |=============================================================================|
 ###############################################################################
 | Phase-space chain (grove) weight history: (numbers in %)
 | chain |   1
 |=============================================================================|
       1 | 100
       2 | 100
       3 | 100
 |-----------------------------------------------------------------------------|
       4 | 100
       5 | 100
       6 | 100
 |=============================================================================|
 ###############################################################################
  Call statistics (current run):
    total       = 2400
    failed kin. = 0
    failed cuts = 0
    passed cuts = 0
    evaluated   = 2400
 ###############################################################################
  MC Integrator is VAMP
 ------------------------------------------------------------------------
  VAMP history (global):
  Pass #1:
  ------------------------------------------------------------------------------
  [vamp]   it   #calls     integral                 average           chi2  eff.
  [vamp]    1      800*  0.0000E+00(0.00E+00)  8.352526E+03(6.97E+00)  0.0 0.000
  [vamp]    2      800*  0.0000E+00(0.00E+00)  8.368810E+03(5.46E+00)  0.0 0.000
  [vamp]    3      800*  0.0000E+00(0.00E+00)  8.368624E+03(5.53E+00)  0.0 0.000
  ------------------------------------------------------------------------------
  Channel histories: [undefined]
  Pass #2:
  ------------------------------------------------------------------------------
  [vamp]   it   #calls     integral                 average           chi2  eff.
  [vamp]    1      800*  0.0000E+00(0.00E+00)  8.360255E+03(5.63E+00)  0.0 0.000
  [vamp]    2      800*  0.0000E+00(0.00E+00)  8.352563E+03(5.62E+00)  0.0 0.000
  [vamp]    3      800*  0.0000E+00(0.00E+00)  8.354186E+03(5.56E+00)  0.0 0.000
  ------------------------------------------------------------------------------
  Channel histories: [undefined]
 ------------------------------------------------------------------------
  Inequivalent channels:
    Channel 1:    Mult. = 1    Symm. = 1    Invar.: TF
  Equivalence list:
    Equivalent channels: 1 1
      Permutation: 1 2
      Mode:        3 0
 ------------------------------------------------------------------------
  Weights of channel chains (groves):
    1 1.0000000000
 ###############################################################################
  Beam data (collision):
    e-  (mass = 0.0000000E+00 GeV)
    e+  (mass = 0.0000000E+00 GeV)
    sqrts = 1.000000000000E+02 GeV
 ###############################################################################
    No cuts used.
 ------------------------------------------------------------------------
    No scale expression was given.
 ------------------------------------------------------------------------
    No factorization scale expression was given.
 ------------------------------------------------------------------------
    No renormalization scale expression was given.
 ------------------------------------------------------------------------
    No weight expression was given.
 ###############################################################################
  Summary of quantum-number states:
   + sign: allowed and contributing
   no +  : switched off at runtime
 ------------------------------------------------------------------------
  Term #1
    1  [f(11) h(-1) / f(-11) h(-1) / f(13) h(-1) / f(-13) h(-1)]
    2  [f(11) h(-1) / f(-11) h(-1) / f(13) h(-1) / f(-13) h(1)]
    3  [f(11) h(-1) / f(-11) h(-1) / f(13) h(1) / f(-13) h(-1)]
    4  [f(11) h(-1) / f(-11) h(-1) / f(13) h(1) / f(-13) h(1)]
  + 5  [f(11) h(-1) / f(-11) h(1) / f(13) h(-1) / f(-13) h(-1)]
  + 6  [f(11) h(-1) / f(-11) h(1) / f(13) h(-1) / f(-13) h(1)]
  + 7  [f(11) h(-1) / f(-11) h(1) / f(13) h(1) / f(-13) h(-1)]
  + 8  [f(11) h(-1) / f(-11) h(1) / f(13) h(1) / f(-13) h(1)]
  + 9  [f(11) h(1) / f(-11) h(-1) / f(13) h(-1) / f(-13) h(-1)]
  + 10  [f(11) h(1) / f(-11) h(-1) / f(13) h(-1) / f(-13) h(1)]
  + 11  [f(11) h(1) / f(-11) h(-1) / f(13) h(1) / f(-13) h(-1)]
  + 12  [f(11) h(1) / f(-11) h(-1) / f(13) h(1) / f(-13) h(1)]
    13  [f(11) h(1) / f(-11) h(1) / f(13) h(-1) / f(-13) h(-1)]
    14  [f(11) h(1) / f(-11) h(1) / f(13) h(-1) / f(-13) h(1)]
    15  [f(11) h(1) / f(-11) h(1) / f(13) h(1) / f(-13) h(-1)]
    16  [f(11) h(1) / f(-11) h(1) / f(13) h(1) / f(-13) h(1)]
 ###############################################################################
 Variable list:
 ee =  3.000000000000E-01
 me =  0.000000000000E+00
 mmu =  1.000000000000E+01
 mtau =  1.777000000000E+00
 particle = PDG(0)
 E_LEPTON = PDG(11)
 e- = PDG(11)
 e1 = PDG(11)
 e+ = PDG(-11)
 E1 = PDG(-11)
 MU_LEPTON = PDG(13)
 m- = PDG(13)
 e2 = PDG(13)
 mu- = PDG(13)
 m+ = PDG(-13)
 E2 = PDG(-13)
 mu+ = PDG(-13)
 TAU_LEPTON = PDG(15)
 t- = PDG(15)
 e3 = PDG(15)
 ta- = PDG(15)
 tau- = PDG(15)
 t+ = PDG(-15)
 E3 = PDG(-15)
 ta+ = PDG(-15)
 tau+ = PDG(-15)
 PHOTON = PDG(22)
 A = PDG(22)
 gamma = PDG(22)
 photon = PDG(22)
 charged = PDG(11, 13, 15, -11, -13, -15)
 neutral = PDG(22)
 colored = PDG()
 sqrts =  1.000000000000E+02
 luminosity =  0.000000000000E+00
 ?sf_trace = false
 $sf_trace_file = ""
 ?sf_allow_s_mapping = true
 $lhapdf_dir = ""
 $lhapdf_file = ""
 $lhapdf_photon_file = ""
 lhapdf_member = 0
 lhapdf_photon_scheme = 0
 $pdf_builtin_set = "CTEQ6L"
 ?hoppet_b_matching = false
 isr_alpha =  0.000000000000E+00
 isr_q_max =  0.000000000000E+00
 isr_mass =  0.000000000000E+00
 isr_order = 3
 ?isr_recoil = false
 ?isr_keep_energy = false
 ?isr_handler = false
 $isr_handler_mode = "trivial"
 epa_alpha =  0.000000000000E+00
 epa_x_min =  0.000000000000E+00
 epa_q_min =  0.000000000000E+00
 epa_q_max =  0.000000000000E+00
 epa_mass =  0.000000000000E+00
 ?epa_recoil = false
 ?epa_keep_energy = false
 ?epa_handler = false
 $epa_handler_mode = "trivial"
 ewa_x_min =  0.000000000000E+00
 ewa_pt_max =  0.000000000000E+00
 ewa_mass =  0.000000000000E+00
 ?ewa_recoil = false
 ?ewa_keep_energy = false
 ?circe1_photon1 = false
 ?circe1_photon2 = false
 [undefined] circe1_sqrts = [unknown real]
 ?circe1_generate = true
 ?circe1_map = true
 circe1_mapping_slope =  2.000000000000E+00
 circe1_eps =  1.000000000000E-05
 circe1_ver = 0
 circe1_rev = 0
 $circe1_acc = "SBAND"
 circe1_chat = 0
 ?circe1_with_radiation = false
 ?circe2_polarized = true
 [undefined] $circe2_file = [unknown string]
 $circe2_design = "*"
 gaussian_spread1 =  0.000000000000E+00
 gaussian_spread2 =  0.000000000000E+00
 [undefined] $beam_events_file = [unknown string]
 ?beam_events_warn_eof = true
 ?energy_scan_normalize = false
 ?logging = true
 [undefined] $job_id = [unknown string]
 [undefined] $compile_workspace = [unknown string]
 seed = 1
 $model_name = "QED"
 [undefined] process_num_id = [unknown integer]
 $method = "omega"
 ?report_progress = true
 [user variable] ?me_verbose = false
 $restrictions = ""
 ?omega_write_phs_output = false
 $omega_flags = ""
 ?read_color_factors = true
 ?slha_read_input = true
 ?slha_read_spectrum = true
 ?slha_read_decays = false
 $library_name = "process_log_lib"
 ?alphas_is_fixed = true
 ?alphas_from_lhapdf = false
 ?alphas_from_pdf_builtin = false
 alphas_order = 0
 alphas_nf = 5
 ?alphas_from_mz = false
 ?alphas_from_lambda_qcd = false
 lambda_qcd =  2.000000000000E-01
 ?fatal_beam_decay = true
 ?helicity_selection_active = true
 helicity_selection_threshold =  1.000000000000E+10
 helicity_selection_cutoff = 1000
 $rng_method = "tao"
 ?vis_diags = false
 ?vis_diags_color = false
 ?check_event_file = true
 $event_file_version = ""
 n_events = 0
 event_index_offset = 0
 ?unweighted = true
 safety_factor =  1.000000000000E+00
 ?negative_weights = false
 ?resonance_history = false
 resonance_on_shell_limit =  4.000000000000E+00
 resonance_on_shell_turnoff =  0.000000000000E+00
 resonance_background_factor =  1.000000000000E+00
 ?keep_beams = false
 ?keep_remnants = true
 ?recover_beams = true
 ?update_event = false
 ?update_sqme = false
 ?update_weight = false
 ?use_alphas_from_file = false
 ?use_scale_from_file = false
 ?allow_decays = true
 ?auto_decays = false
 auto_decays_multiplicity = 2
 ?auto_decays_radiative = false
 ?decay_rest_frame = false
 ?isotropic_decay = false
 ?diagonal_decay = false
 [undefined] decay_helicity = [unknown integer]
 ?polarized_events = false
 $polarization_mode = "helicity"
+?colorize_subevt = false
 tolerance =  0.000000000000E+00
 checkpoint = 0
 event_callback_interval = 0
 ?pacify = false
 $out_file = ""
 ?out_advance = true
 real_range = <real_range>
 real_precision = <real_precision>
 real_epsilon = <real_epsilon>
 real_tiny = <real_tiny>
 $integration_method = "vamp"
 threshold_calls = 10
 min_calls_per_channel = 10
 min_calls_per_bin = 10
 min_bins = 3
 max_bins = 20
 ?stratified = true
 ?use_vamp_equivalences = true
 ?vamp_verbose = false
 ?vamp_history_global = true
 ?vamp_history_global_verbose = false
 ?vamp_history_channels = false
 ?vamp_history_channels_verbose = false
 $run_id = ""
 n_calls_test = 0
 ?integration_timer = true
 ?check_grid_file = true
 accuracy_goal =  0.000000000000E+00
 error_goal =  0.000000000000E+00
 relative_error_goal =  0.000000000000E+00
 integration_results_verbosity = 1
 error_threshold =  0.000000000000E+00
 channel_weights_power =  2.500000000000E-01
 [undefined] $integrate_workspace = [unknown string]
 $phs_method = "wood"
 ?vis_channels = false
 ?check_phs_file = true
 $phs_file = ""
 ?phs_only = false
 phs_threshold_s =  5.000000000000E+01
 phs_threshold_t =  1.000000000000E+02
 phs_off_shell = 2
 phs_t_channel = 6
 phs_e_scale =  1.000000000000E+01
 phs_m_scale =  1.000000000000E+01
 phs_q_scale =  1.000000000000E+01
 ?phs_keep_nonresonant = true
 ?phs_step_mapping = true
 ?phs_step_mapping_exp = true
 ?phs_s_mapping = true
 ?vis_history = false
 n_bins = 20
 ?normalize_bins = false
 $obs_label = ""
 $obs_unit = ""
 $title = ""
 $description = ""
 $x_label = ""
 $y_label = ""
 graph_width_mm = 130
 graph_height_mm = 90
 ?y_log = false
 ?x_log = false
 [undefined] x_min = [unknown real]
 [undefined] x_max = [unknown real]
 [undefined] y_min = [unknown real]
 [undefined] y_max = [unknown real]
 $gmlcode_bg = ""
 $gmlcode_fg = ""
 [undefined] ?draw_histogram = [unknown logical]
 [undefined] ?draw_base = [unknown logical]
 [undefined] ?draw_piecewise = [unknown logical]
 [undefined] ?fill_curve = [unknown logical]
 [undefined] ?draw_curve = [unknown logical]
 [undefined] ?draw_errors = [unknown logical]
 [undefined] ?draw_symbols = [unknown logical]
 [undefined] $fill_options = [unknown string]
 [undefined] $draw_options = [unknown string]
 [undefined] $err_options = [unknown string]
 [undefined] $symbol = [unknown string]
 ?analysis_file_only = false
 kt_algorithm = 0
 cambridge_algorithm = 1
 antikt_algorithm = 2
 genkt_algorithm = 3
 cambridge_for_passive_algorithm = 11
 genkt_for_passive_algorithm = 13
 ee_kt_algorithm = 50
 ee_genkt_algorithm = 53
 plugin_algorithm = 99
 undefined_jet_algorithm = 999
 jet_algorithm = 999
 jet_r =  0.000000000000E+00
 jet_p =  0.000000000000E+00
 jet_ycut =  0.000000000000E+00
 ?keep_flavors_when_clustering = false
 $sample = ""
 $sample_normalization = "auto"
 ?sample_pacify = false
 ?sample_select = true
 sample_max_tries = 10000
 sample_split_n_evt = 0
 sample_split_n_kbytes = 0
 sample_split_index = 0
 $rescan_input_format = "raw"
 ?read_raw = true
 ?write_raw = true
 $extension_raw = "evx"
 $extension_default = "evt"
 $debug_extension = "debug"
 ?debug_process = true
 ?debug_transforms = true
 ?debug_decay = true
 ?debug_verbose = true
 $dump_extension = "pset.dat"
 ?dump_compressed = false
 ?dump_weights = false
 ?dump_summary = false
 ?dump_screen = false
 ?hepevt_ensure_order = false
 $extension_hepevt = "hepevt"
 $extension_ascii_short = "short.evt"
 $extension_ascii_long = "long.evt"
 $extension_athena = "athena.evt"
 $extension_mokka = "mokka.evt"
 $lhef_version = "2.0"
 $lhef_extension = "lhe"
 ?lhef_write_sqme_prc = true
 ?lhef_write_sqme_ref = false
 ?lhef_write_sqme_alt = true
 $extension_lha = "lha"
 $extension_hepmc = "hepmc"
 ?hepmc_output_cross_section = false
 $extension_lcio = "slcio"
 $extension_stdhep = "hep"
 $extension_stdhep_up = "up.hep"
 $extension_stdhep_ev4 = "ev4.hep"
 $extension_hepevt_verb = "hepevt.verb"
 $extension_lha_verb = "lha.verb"
 ?allow_shower = true
 ?ps_fsr_active = false
 ?ps_isr_active = false
 ?ps_taudec_active = false
 ?muli_active = false
 $shower_method = "WHIZARD"
 ?shower_verbose = false
 $ps_PYTHIA_PYGIVE = ""
 ps_mass_cutoff =  1.000000000000E+00
 ps_fsr_lambda =  2.900000000000E-01
 ps_isr_lambda =  2.900000000000E-01
 ps_max_n_flavors = 5
 ?ps_isr_alphas_running = true
 ?ps_fsr_alphas_running = true
 ps_fixed_alphas =  0.000000000000E+00
 ?ps_isr_pt_ordered = false
 ?ps_isr_angular_ordered = true
 ps_isr_primordial_kt_width =  0.000000000000E+00
 ps_isr_primordial_kt_cutoff =  5.000000000000E+00
 ps_isr_z_cutoff =  9.990000000000E-01
 ps_isr_minenergy =  1.000000000000E+00
 ps_isr_tscalefactor =  1.000000000000E+00
 ?ps_isr_only_onshell_emitted_partons = false
 ?allow_hadronization = true
 ?hadronization_active = false
 $hadronization_method = "PYTHIA6"
 hadron_enhanced_fraction =  1.000000000000E-02
 hadron_enhanced_width =  2.000000000000E+00
 ?ps_tauola_photos = false
 ?ps_tauola_transverse = false
 ?ps_tauola_dec_rad_cor = true
 ps_tauola_dec_mode1 = 0
 ps_tauola_dec_mode2 = 0
 ps_tauola_mh =  1.250000000000E+02
 ps_tauola_mix_angle =  9.000000000000E+01
 ?ps_tauola_pol_vector = false
 ?mlm_matching = false
 mlm_Qcut_ME =  0.000000000000E+00
 mlm_Qcut_PS =  0.000000000000E+00
 mlm_ptmin =  0.000000000000E+00
 mlm_etamax =  0.000000000000E+00
 mlm_Rmin =  0.000000000000E+00
 mlm_Emin =  0.000000000000E+00
 mlm_nmaxMEjets = 0
 mlm_ETclusfactor =  2.000000000000E-01
 mlm_ETclusminE =  5.000000000000E+00
 mlm_etaclusfactor =  1.000000000000E+00
 mlm_Rclusfactor =  1.000000000000E+00
 mlm_Eclusfactor =  1.000000000000E+00
 ?powheg_matching = false
 ?powheg_use_singular_jacobian = false
 powheg_grid_size_xi = 5
 powheg_grid_size_y = 5
 powheg_grid_sampling_points = 500000
 powheg_pt_min =  1.000000000000E+00
 powheg_lambda =  2.000000000000E-01
 ?powheg_rebuild_grids = false
 ?powheg_test_sudakov = false
 ?powheg_disable_sudakov = false
 ?ckkw_matching = false
 ?omega_openmp => false
 ?openmp_is_active = false
 openmp_num_threads_default = 1
 openmp_num_threads = 1
 ?openmp_logging = false
 ?mpi_logging = false
 $born_me_method = ""
 $loop_me_method = ""
 $correlation_me_method = ""
 $real_tree_me_method = ""
 $dglap_me_method = ""
 ?test_soft_limit = false
 ?test_coll_limit = false
 ?test_anti_coll_limit = false
 $select_alpha_regions = ""
 $virtual_selection = "Full"
 ?virtual_collinear_resonance_aware = true
 blha_top_yukawa = -1.000000000000E+00
 $blha_ew_scheme = "alpha_qed"
 openloops_verbosity = 1
 ?openloops_use_cms = true
 openloops_phs_tolerance = 7
 openloops_stability_log = 0
 ?openloops_switch_off_muon_yukawa = false
 $openloops_extra_cmd = ""
 ?openloops_use_collier = true
 ?disable_subtraction = false
 fks_dij_exp1 =  1.000000000000E+00
 fks_dij_exp2 =  1.000000000000E+00
 fks_xi_min =  1.000000000000E-07
 fks_y_max =  1.000000000000E+00
 ?vis_fks_regions = false
 fks_xi_cut =  1.000000000000E+00
 fks_delta_zero =  2.000000000000E+00
 fks_delta_i =  2.000000000000E+00
 $fks_mapping_type = "default"
 $resonances_exclude_particles = "default"
 alpha_power = 2
 alphas_power = 0
 ?combined_nlo_integration = false
 ?fixed_order_nlo_events = false
 ?check_event_weights_against_xsection = false
 ?keep_failed_events = false
 gks_multiplicity = 0
 $gosam_filter_lo = ""
 $gosam_filter_nlo = ""
 $gosam_symmetries = "family,generation"
 form_threads = 2
 form_workspace = 1000
 $gosam_fc = ""
 mult_call_real =  1.000000000000E+00
 mult_call_virt =  1.000000000000E+00
 mult_call_dglap =  1.000000000000E+00
 $dalitz_plot = ""
 $nlo_correction_type = "QCD"
 $exclude_gauge_splittings = "c:b:t:e2:e3"
 ?nlo_use_born_scale = true
 ?nlo_cut_all_sqmes = true
 ?nlo_use_real_partition = false
 real_partition_scale =  1.000000000000E+01
 $fc = Fortran-compiler
 $fcflags = Fortran-flags
 ?rebuild_library = true
 ?recompile_library = false
 ?rebuild_phase_space = true
 ?rebuild_grids = true
 ?powheg_rebuild_grids = true
 ?rebuild_events = true
 [undefined] num_id(process_log_1_p1) = [unknown integer]
 [undefined] integral(process_log_1_p1) = [unknown real]
 [undefined] error(process_log_1_p1) = [unknown real]
 ###############################################################################
Index: trunk/share/tests/functional_tests/ref-output/analyze_5.ref
===================================================================
--- trunk/share/tests/functional_tests/ref-output/analyze_5.ref	(revision 0)
+++ trunk/share/tests/functional_tests/ref-output/analyze_5.ref	(revision 8164)
@@ -0,0 +1,190 @@
+?openmp_logging = false
+?vis_history = false
+?integration_timer = false
+?pacify = true
+seed = 0
+| Process library 'analyze_5_lib': recorded process 'analyze_5_p'
+sqrts =  1.00000E+02
+?sample_pacify = true
+?debug_process = false
+?debug_transforms = true
+$sample = "analyze_5"
+?colorize_subevt = true
+n_events = 1
+| Starting simulation for process 'analyze_5_p'
+| Simulate: process 'analyze_5_p' needs integration
+| Integrate: current process library needs compilation
+| Process library 'analyze_5_lib': compiling ...
+| Process library 'analyze_5_lib': writing makefile
+| Process library 'analyze_5_lib': removing old files
+| Process library 'analyze_5_lib': writing driver
+| Process library 'analyze_5_lib': creating source code
+| Process library 'analyze_5_lib': compiling sources
+| Process library 'analyze_5_lib': linking
+| Process library 'analyze_5_lib': loading
+| Process library 'analyze_5_lib': ... success.
+| Integrate: compilation done
+| RNG: Initializing TAO random-number generator
+| RNG: Setting seed for random-number generator to 0
+| Initializing integration for process analyze_5_p:
+| Beam structure: [any particles]
+| Beam data (collision):
+|   u     (mass = 0.0000000E+00 GeV)
+|   ubar  (mass = 0.0000000E+00 GeV)
+|   sqrts = 1.000000000000E+02 GeV
+| Phase space: generating configuration ...
+| Phase space: ... success.
+| Phase space: writing configuration file 'analyze_5_p.i1.phs'
+| ------------------------------------------------------------------------
+| Process [scattering]: 'analyze_5_p'
+|   Library name  = 'analyze_5_lib'
+|   Process index = 1
+|   Process components:
+|     1: 'analyze_5_p_i1':   u, ubar => u, ubar [omega]
+| ------------------------------------------------------------------------
+| Phase space: 3 channels, 2 dimensions
+| Phase space: found 3 channels, collected in 2 groves.
+| Phase space: Using 3 equivalences between channels.
+| Phase space: wood
+| Applying user-defined cuts.
+| Starting integration for process 'analyze_5_p'
+| Integrate: iterations = 1:1000
+| Integrator: 2 chains, 3 channels, 2 dimensions
+| Integrator: Using VAMP channel equivalences
+| Integrator: 1000 initial calls, 20 bins, stratified = T
+| Integrator: VAMP
+|=============================================================================|
+| It      Calls  Integral[fb]  Error[fb]   Err[%]    Acc  Eff[%]   Chi2 N[It] |
+|=============================================================================|
+   1        864     1.407E+08   7.23E+06    5.14    1.51     6.6
+|-----------------------------------------------------------------------------|
+   1        864     1.407E+08   7.23E+06    5.14    1.51     6.6
+|=============================================================================|
+| Simulate: integration done
+| Simulate: using integration grids from file 'analyze_5_p.m1.vg'
+| RNG: Initializing TAO random-number generator
+| RNG: Setting seed for random-number generator to 1
+| Simulation: requested number of events = 1
+|             corr. to luminosity [fb-1] =   7.1098E-09
+| Events: writing to ASCII file 'analyze_5.debug'
+| Events: writing to raw file 'analyze_5.evx'
+| Events: generating 1 unweighted, unpolarized events ...
+| Events: event normalization mode '1'
+|         ... event sample complete.
+| Events: actual unweighting efficiency =  20.00 %
+| Events: closing ASCII file 'analyze_5.debug'
+| Events: closing raw file 'analyze_5.evx'
+n_events = 100
+| Starting simulation for process 'analyze_5_p'
+| Simulate: using integration grids from file 'analyze_5_p.m1.vg'
+| RNG: Initializing TAO random-number generator
+| RNG: Setting seed for random-number generator to 2
+| Simulation: requested number of events = 100
+|             corr. to luminosity [fb-1] =   7.1098E-07
+| Events: writing to event dump file 'analyze_5.pset.dat'
+| Events: writing to raw file 'analyze_5.evx'
+| Events: generating 100 unweighted, unpolarized events ...
+| Events: event normalization mode '1'
+|         ... event sample complete.
+| Events: actual unweighting efficiency =   7.63 %
+Warning: Encountered events with excess weight: 6 events (  6.000 %)
+| Maximum excess weight = 2.027E+00
+| Average excess weight = 2.201E-02
+| Events: closing event dump file 'analyze_5.pset.dat'
+| Events: closing raw file 'analyze_5.evx'
+$out_file = "analyze_5.dat"
+| Opening file 'analyze_5.dat' for output
+| Writing analysis data to file 'analyze_5.dat'
+| Closing file 'analyze_5.dat' for output
+| There were no errors and    1 warning(s).
+| WHIZARD run finished.
+|=============================================================================|
+Contents of analyze_5.debug
+========================================================================
+ Event #1
+------------------------------------------------------------------------
+   Unweighted         = T
+   Normalization      = '1'
+   Helicity handling  = drop
+   Keep correlations  = F
+   Colorize subevent  = T
+------------------------------------------------------------------------
+   Squared matrix el. (ref) =  1.40198E+04
+   Squared matrix el. (prc) =  1.40198E+04
+   Event weight (ref)       =  1.00000E+00
+   Event weight (prc)       =  1.00000E+00
+------------------------------------------------------------------------
+   Selected MCI group = 1
+   Selected term      = 1
+   Selected channel   = 2
+------------------------------------------------------------------------
+   Passed selection   = T
+   Reweighting factor =  1.00000E+00
+   Analysis flag      = T
+========================================================================
+ Event transform: trivial (hard process)
+------------------------------------------------------------------------
+   Associated process: 'analyze_5_p'
+   TAO random-number generator:
+     seed  = 2
+     calls = 3
+   Number of tries = 1
+------------------------------------------------------------------------
+ Particle set:
+------------------------------------------------------------------------
+ Particle 1 [i] f(2)c(1 )
+ E =   5.000000E+01
+ P =   0.000000E+00  0.000000E+00  5.000000E+01
+ T =   0.000000000E+00
+ Children: 3 4
+ Particle 2 [i] f(-2)c(-1 )
+ E =   5.000000E+01
+ P =   0.000000E+00  0.000000E+00 -5.000000E+01
+ T =   0.000000000E+00
+ Children: 3 4
+ Particle 3 [o] f(2)c(6 )
+ E =   5.000000E+01
+ P =  -8.759275E+00  6.269636E+00  4.882588E+01
+ T =   0.000000000E+00
+ Parents:  1 2
+ Particle 4 [o] f(-2)c(-6 )
+ E =   5.000000E+01
+ P =   8.759275E+00 -6.269636E+00 -4.882588E+01
+ T =   0.000000000E+00
+ Parents:  1 2
+========================================================================
+ Local variables:
+------------------------------------------------------------------------
+sqrts* =  1.00000E+02
+sqrts_hat* =>  1.00000E+02
+n_in* => 2
+n_out* => 2
+n_tot* => 4
+$process_id* => "analyze_5_p"
+process_num_id* => [unknown integer]
+sqme* =>  1.40198E+04
+sqme_ref* =>  1.40198E+04
+event_index* => 1
+event_weight* =>  1.00000E+00
+event_weight_ref* =>  1.00000E+00
+event_excess* =>  0.00000E+00
+------------------------------------------------------------------------
+ subevent:
+ 1 prt(i:2|1/|-5.0000000E+01; 0.0000000E+00, 0.0000000E+00,-5.0000000E+01| 0.0000000E+00| 1)
+ 2 prt(i:-2|/1|-5.0000000E+01; 0.0000000E+00, 0.0000000E+00, 5.0000000E+01| 0.0000000E+00| 2)
+ 3 prt(o:2|6/| 5.0000000E+01;-8.7592749E+00, 6.2696356E+00, 4.8825882E+01| 0.0000000E+00| 3)
+ 4 prt(o:-2|/6| 5.0000000E+01; 8.7592749E+00,-6.2696356E+00,-4.8825882E+01| 0.0000000E+00| 4)
+========================================================================
+Contents of analyze_5.dat
+###############################################################################
+# Observable: ncol
+average     =  1.800000000000E-01
+error[abs]  =  3.861229196654E-02
+error[rel]  =  2.145127331474E-01
+n_entries   = 100
+###############################################################################
+# Observable: nacl
+average     =  1.800000000000E-01
+error[abs]  =  3.861229196654E-02
+error[rel]  =  2.145127331474E-01
+n_entries   = 100
Index: trunk/share/tests/functional_tests/ref-output/vars.ref
===================================================================
--- trunk/share/tests/functional_tests/ref-output/vars.ref	(revision 8163)
+++ trunk/share/tests/functional_tests/ref-output/vars.ref	(revision 8164)
@@ -1,372 +1,373 @@
 ?openmp_logging = false
 [user variable] foo = -7.800000000000E-02
 [user variable] bar = 1
 [user variable] a =  2.010000000000E-05
 [user variable] i = 3
 [user variable] foo =  2.922000000000E+00
 [user variable] i = 9
 [user variable] foo =  2.922000000000E+00
 [user variable] bar = 1
 [user variable] i = 9
 [user variable] k = 1
 [user variable] k2 =  1.000000000000E+00
 [user variable] i = -1
 [user variable] k = 2
 [user variable] k2 =  4.000000000000E+00
 [user variable] i = -2
 [user variable] k = 3
 [user variable] k2 =  9.000000000000E+00
 [user variable] i = -3
 [user variable] k = 4
 [user variable] k2 =  1.600000000000E+01
 [user variable] i = -4
 [user variable] k = 8
 [user variable] k2 =  6.400000000000E+01
 [user variable] i = -8
 [user variable] i = 9
 [user variable] MW =  7.980000000000E+01
 [user variable] MW =  7.980000000000E+01
 SM.mtau =>  8.000000000000E-01
 SM.mW =>  8.011900000000E+01
 SM.mW =>  8.011900000000E+01
 SM.sw* =>  4.775372811515E-01
 SM.mW =>  7.500000000000E+01
 SM.sw* =>  5.688014954824E-01
 SM.mW =>  8.000000000000E+01
 SM.sw* =>  4.799305327664E-01
 SM.mW =>  8.050000000000E+01
 SM.sw* =>  4.697684723671E-01
 SM.mW =>  8.100000000000E+01
 SM.sw* =>  4.593162187090E-01
 SM.mW =>  8.150000000000E+01
 SM.sw* =>  4.485534858838E-01
 SM.mW =>  8.200000000000E+01
 SM.sw* =>  4.374573583998E-01
 SM.mW =>  8.300000000000E+01
 SM.sw* =>  4.141569403361E-01
 SM.mW =>  8.469722796445E+01
 SM.sw* =>  3.705366373038E-01
 SM.mW =>  8.642916174533E+01
 SM.sw* =>  3.188332912310E-01
 SM.mW =>  8.819651102555E+01
 SM.sw* =>  2.540459583362E-01
 SM.mW =>  9.000000000000E+01
 SM.sw* =>  1.609055729882E-01
 mW is 80.119 and sw is:   0.4775
 seed = 32
 seed = 32
 seed = 30
 seed = 30
 seed = 28
 seed = 28
 seed = 26
 seed = 26
 seed = 24
 seed = 24
 seed = 22
 seed = 22
 seed = 20
 seed = 20
 seed = 18
 seed = 18
 seed = 16
 seed = 16
 seed = 14
 seed = 14
 seed = 12
 seed = 12
 seed = 10
 seed = 10
 seed = 8
 seed = 8
 seed = 6
 seed = 6
 seed = 4
 seed = 4
 seed = 2
 seed = 2
 [user variable] $str = "foo"
 [user variable] $str = "bar"
 [user variable] ?ok = false
 [user variable] ?ok = false
 [user variable] ?ok = true
 ?sf_trace = false
 ?sf_allow_s_mapping = true
 ?hoppet_b_matching = false
 ?isr_recoil = false
 ?isr_keep_energy = false
 ?isr_handler = false
 ?epa_recoil = false
 ?epa_keep_energy = false
 ?epa_handler = false
 ?ewa_recoil = false
 ?ewa_keep_energy = false
 ?circe1_photon1 = false
 ?circe1_photon2 = false
 ?circe1_generate = true
 ?circe1_map = true
 ?circe1_with_radiation = false
 ?circe2_polarized = true
 ?beam_events_warn_eof = true
 ?energy_scan_normalize = false
 ?logging => true
 ?report_progress = true
 [user variable] ?me_verbose = false
 ?omega_write_phs_output = false
 ?read_color_factors = true
 ?slha_read_input = true
 ?slha_read_spectrum = true
 ?slha_read_decays = false
 ?alphas_is_fixed = true
 ?alphas_from_lhapdf = false
 ?alphas_from_pdf_builtin = false
 ?alphas_from_mz = false
 ?alphas_from_lambda_qcd = false
 ?fatal_beam_decay = true
 ?helicity_selection_active = true
 ?vis_diags = false
 ?vis_diags_color = false
 ?check_event_file = true
 ?unweighted = true
 ?negative_weights = false
 ?resonance_history = false
 ?keep_beams = false
 ?keep_remnants = true
 ?recover_beams = true
 ?update_event = false
 ?update_sqme = false
 ?update_weight = false
 ?use_alphas_from_file = false
 ?use_scale_from_file = false
 ?allow_decays = true
 ?auto_decays = false
 ?auto_decays_radiative = false
 ?decay_rest_frame = false
 ?isotropic_decay = false
 ?diagonal_decay = false
 ?polarized_events = false
+?colorize_subevt = false
 ?pacify = false
 ?out_advance = true
 ?stratified = true
 ?use_vamp_equivalences = true
 ?vamp_verbose = false
 ?vamp_history_global = true
 ?vamp_history_global_verbose = false
 ?vamp_history_channels = false
 ?vamp_history_channels_verbose = false
 ?integration_timer = true
 ?check_grid_file = true
 ?vis_channels = false
 ?check_phs_file = true
 ?phs_only = false
 ?phs_keep_nonresonant = true
 ?phs_step_mapping = true
 ?phs_step_mapping_exp = true
 ?phs_s_mapping = true
 ?vis_history = false
 ?normalize_bins = false
 ?y_log = false
 ?x_log = false
 [undefined] ?draw_histogram = [unknown logical]
 [undefined] ?draw_base = [unknown logical]
 [undefined] ?draw_piecewise = [unknown logical]
 [undefined] ?fill_curve = [unknown logical]
 [undefined] ?draw_curve = [unknown logical]
 [undefined] ?draw_errors = [unknown logical]
 [undefined] ?draw_symbols = [unknown logical]
 ?analysis_file_only = false
 ?keep_flavors_when_clustering = false
 ?sample_pacify = false
 ?sample_select = true
 ?read_raw = true
 ?write_raw = true
 ?debug_process = true
 ?debug_transforms = true
 ?debug_decay = true
 ?debug_verbose = true
 ?dump_compressed = false
 ?dump_weights = false
 ?dump_summary = false
 ?dump_screen = false
 ?hepevt_ensure_order = false
 ?lhef_write_sqme_prc = true
 ?lhef_write_sqme_ref = false
 ?lhef_write_sqme_alt = true
 ?hepmc_output_cross_section = false
 ?allow_shower = true
 ?ps_fsr_active = false
 ?ps_isr_active = false
 ?ps_taudec_active = false
 ?muli_active = false
 ?shower_verbose = false
 ?ps_isr_alphas_running = true
 ?ps_fsr_alphas_running = true
 ?ps_isr_pt_ordered = false
 ?ps_isr_angular_ordered = true
 ?ps_isr_only_onshell_emitted_partons = false
 ?allow_hadronization = true
 ?hadronization_active = false
 ?ps_tauola_photos = false
 ?ps_tauola_transverse = false
 ?ps_tauola_dec_rad_cor = true
 ?ps_tauola_pol_vector = false
 ?mlm_matching = false
 ?powheg_matching = false
 ?powheg_use_singular_jacobian = false
 ?powheg_rebuild_grids = false
 ?powheg_test_sudakov = false
 ?powheg_disable_sudakov = false
 ?ckkw_matching = false
 ?omega_openmp => false
 ?openmp_is_active* = false
 ?openmp_logging = false
 ?mpi_logging = false
 ?test_soft_limit = false
 ?test_coll_limit = false
 ?test_anti_coll_limit = false
 ?virtual_collinear_resonance_aware = true
 ?openloops_use_cms = true
 ?openloops_switch_off_muon_yukawa = false
 ?openloops_use_collier = true
 ?disable_subtraction = false
 ?vis_fks_regions = false
 ?combined_nlo_integration = false
 ?fixed_order_nlo_events = false
 ?check_event_weights_against_xsection = false
 ?keep_failed_events = false
 ?nlo_use_born_scale = true
 ?nlo_cut_all_sqmes = true
 ?nlo_use_real_partition = false
 ?rebuild_library = true
 ?recompile_library = false
 ?rebuild_phase_space = true
 ?rebuild_grids = true
 ?powheg_rebuild_grids = true
 ?rebuild_events = true
 [user variable] ?ok = true
 [user variable] $str = "foo"
 [user variable] $str = "foobar"
 $sf_trace_file = ""
 $lhapdf_dir = ""
 $lhapdf_file = ""
 $lhapdf_photon_file = ""
 $pdf_builtin_set = "CTEQ6L"
 $isr_handler_mode = "trivial"
 $epa_handler_mode = "trivial"
 $circe1_acc = "SBAND"
 [undefined] $circe2_file = [unknown string]
 $circe2_design = "*"
 [undefined] $beam_events_file = [unknown string]
 [undefined] $job_id = [unknown string]
 [undefined] $compile_workspace = [unknown string]
 $model_name = "SM"
 $method = "omega"
 $restrictions = ""
 $omega_flags = ""
 $library_name = "vars_lib"
 $rng_method = "tao"
 $event_file_version = ""
 $polarization_mode = "helicity"
 $out_file = ""
 $integration_method = "vamp"
 $run_id = ""
 [undefined] $integrate_workspace = [unknown string]
 $phs_method = "default"
 $phs_file = ""
 $obs_label = ""
 $obs_unit = ""
 $title = ""
 $description = ""
 $x_label = ""
 $y_label = ""
 $gmlcode_bg = ""
 $gmlcode_fg = ""
 [undefined] $fill_options = [unknown string]
 [undefined] $draw_options = [unknown string]
 [undefined] $err_options = [unknown string]
 [undefined] $symbol = [unknown string]
 $sample = ""
 $sample_normalization = "auto"
 $rescan_input_format = "raw"
 $extension_raw = "evx"
 $extension_default = "evt"
 $debug_extension = "debug"
 $dump_extension = "pset.dat"
 $extension_hepevt = "hepevt"
 $extension_ascii_short = "short.evt"
 $extension_ascii_long = "long.evt"
 $extension_athena = "athena.evt"
 $extension_mokka = "mokka.evt"
 $lhef_version = "2.0"
 $lhef_extension = "lhe"
 $extension_lha = "lha"
 $extension_hepmc = "hepmc"
 $extension_lcio = "slcio"
 $extension_stdhep = "hep"
 $extension_stdhep_up = "up.hep"
 $extension_stdhep_ev4 = "ev4.hep"
 $extension_hepevt_verb = "hepevt.verb"
 $extension_lha_verb = "lha.verb"
 $shower_method = "WHIZARD"
 $ps_PYTHIA_PYGIVE = ""
 $hadronization_method = "PYTHIA6"
 $born_me_method = ""
 $loop_me_method = ""
 $correlation_me_method = ""
 $real_tree_me_method = ""
 $dglap_me_method = ""
 $select_alpha_regions = ""
 $virtual_selection = "Full"
 $blha_ew_scheme = "alpha_qed"
 $openloops_extra_cmd = ""
 $fks_mapping_type = "default"
 $resonances_exclude_particles = "default"
 $gosam_filter_lo = ""
 $gosam_filter_nlo = ""
 $gosam_symmetries = "family,generation"
 $gosam_fc = ""
 $dalitz_plot = ""
 $nlo_correction_type = "QCD"
 $exclude_gauge_splittings = "c:b:t:e2:e3"
 $fc => Fortran-compiler
 $fcflags => Fortran-flags
 [user variable] $str = "foobar"
 [user variable] q = PDG(2)
 [user variable] q = PDG(2, 1, -2, -1)
 Q is only local and hence not not defined
 ******************************************************************************
 *** ERROR: show: object 'Q' not found
 ******************************************************************************
 |             (WHIZARD run continues)
 SM.u* = PDG(2)
 [user variable] q = PDG(2, 1, -2, -1)
 [user variable] i = 1
 one = 1
 [user variable] i = 2
 two
 [user variable] i = 3
 three
 [user variable] i = 4
 four
 [user variable] i = -1
 [user variable] $str = "i<=0"
 [user variable] i = 1
 [user variable] $str = "i>0"
 [user variable] i = 2
 [user variable] $str = "i>1"
 Testing the complex calculus
 [user variable] ca = ( 2.000000000000E+00, 1.000000000000E+00)
 [user variable] ca = ( 2.000000000000E+00, 1.000000000000E+00)
 [user variable] ia = 2
 [user variable] ia = 2
 [user variable] ra =  2.000000000000E+00
 [user variable] ra =  2.000000000000E+00
 [user variable] cb = ( 3.000000000000E+00, 4.000000000000E+00)
 [user variable] cb = ( 3.000000000000E+00, 4.000000000000E+00)
 ?pacify = true
 [user variable] cc = ( 1.00000E+00, 0.00000E+00)
 ?pacify = true
 [user variable] cc = ( 1.00000E+00, 0.00000E+00)
 | There were  1 error(s) and no warnings.
 | WHIZARD run finished.
 |=============================================================================|
Index: trunk/share/tests/functional_tests/ref-output/show_4.ref
===================================================================
--- trunk/share/tests/functional_tests/ref-output/show_4.ref	(revision 8163)
+++ trunk/share/tests/functional_tests/ref-output/show_4.ref	(revision 8164)
@@ -1,1137 +1,1140 @@
 ?openmp_logging = false
 [user variable] foo = PDG(11, 13, 15)
 [user variable] bar = ( 2.000000000000E+00, 3.000000000000E+00)
 #####################################################
 QED.ee =>  3.028600000000E-01
 QED.me =>  5.110000000000E-04
 QED.mmu =>  1.057000000000E-01
 QED.mtau =>  1.777000000000E+00
 [undefined] sqrts = [unknown real]
 luminosity =  0.000000000000E+00
 isr_alpha =  0.000000000000E+00
 isr_q_max =  0.000000000000E+00
 isr_mass =  0.000000000000E+00
 epa_alpha =  0.000000000000E+00
 epa_x_min =  0.000000000000E+00
 epa_q_min =  0.000000000000E+00
 epa_q_max =  0.000000000000E+00
 epa_mass =  0.000000000000E+00
 ewa_x_min =  0.000000000000E+00
 ewa_pt_max =  0.000000000000E+00
 ewa_mass =  0.000000000000E+00
 [undefined] circe1_sqrts = [unknown real]
 circe1_mapping_slope =  2.000000000000E+00
 circe1_eps =  1.000000000000E-05
 gaussian_spread1 =  0.000000000000E+00
 gaussian_spread2 =  0.000000000000E+00
 lambda_qcd =  2.000000000000E-01
 helicity_selection_threshold =  1.000000000000E+10
 safety_factor =  1.000000000000E+00
 resonance_on_shell_limit =  4.000000000000E+00
 resonance_on_shell_turnoff =  0.000000000000E+00
 resonance_background_factor =  1.000000000000E+00
 tolerance =  0.000000000000E+00
 real_epsilon* = <real_epsilon>
 real_tiny* = <real_tiny>
 accuracy_goal =  0.000000000000E+00
 error_goal =  0.000000000000E+00
 relative_error_goal =  0.000000000000E+00
 error_threshold =  0.000000000000E+00
 channel_weights_power =  2.500000000000E-01
 phs_threshold_s =  5.000000000000E+01
 phs_threshold_t =  1.000000000000E+02
 phs_e_scale =  1.000000000000E+01
 phs_m_scale =  1.000000000000E+01
 phs_q_scale =  1.000000000000E+01
 [undefined] x_min = [unknown real]
 [undefined] x_max = [unknown real]
 [undefined] y_min = [unknown real]
 [undefined] y_max = [unknown real]
 jet_r =  0.000000000000E+00
 jet_p =  0.000000000000E+00
 jet_ycut =  0.000000000000E+00
 ps_mass_cutoff =  1.000000000000E+00
 ps_fsr_lambda =  2.900000000000E-01
 ps_isr_lambda =  2.900000000000E-01
 ps_fixed_alphas =  0.000000000000E+00
 ps_isr_primordial_kt_width =  0.000000000000E+00
 ps_isr_primordial_kt_cutoff =  5.000000000000E+00
 ps_isr_z_cutoff =  9.990000000000E-01
 ps_isr_minenergy =  1.000000000000E+00
 ps_isr_tscalefactor =  1.000000000000E+00
 hadron_enhanced_fraction =  1.000000000000E-02
 hadron_enhanced_width =  2.000000000000E+00
 ps_tauola_mh =  1.250000000000E+02
 ps_tauola_mix_angle =  9.000000000000E+01
 mlm_Qcut_ME =  0.000000000000E+00
 mlm_Qcut_PS =  0.000000000000E+00
 mlm_ptmin =  0.000000000000E+00
 mlm_etamax =  0.000000000000E+00
 mlm_Rmin =  0.000000000000E+00
 mlm_Emin =  0.000000000000E+00
 mlm_ETclusfactor =  2.000000000000E-01
 mlm_ETclusminE =  5.000000000000E+00
 mlm_etaclusfactor =  1.000000000000E+00
 mlm_Rclusfactor =  1.000000000000E+00
 mlm_Eclusfactor =  1.000000000000E+00
 powheg_pt_min =  1.000000000000E+00
 powheg_lambda =  2.000000000000E-01
 blha_top_yukawa = -1.000000000000E+00
 fks_dij_exp1 =  1.000000000000E+00
 fks_dij_exp2 =  1.000000000000E+00
 fks_xi_min =  1.000000000000E-07
 fks_y_max =  1.000000000000E+00
 fks_xi_cut =  1.000000000000E+00
 fks_delta_zero =  2.000000000000E+00
 fks_delta_i =  2.000000000000E+00
 mult_call_real =  1.000000000000E+00
 mult_call_virt =  1.000000000000E+00
 mult_call_dglap =  1.000000000000E+00
 real_partition_scale =  1.000000000000E+01
 #####################################################
 QED.charged* = PDG(11, 13, 15, -11, -13, -15)
 #####################################################
 [user variable] foo = PDG(11, 13, 15)
 #####################################################
 [user variable] bar = ( 2.000000000000E+00, 3.000000000000E+00)
 #####################################################
 $sf_trace_file = ""
 $lhapdf_dir = ""
 $lhapdf_file = ""
 $lhapdf_photon_file = ""
 $pdf_builtin_set = "CTEQ6L"
 $isr_handler_mode = "trivial"
 $epa_handler_mode = "trivial"
 $circe1_acc = "SBAND"
 [undefined] $circe2_file = [unknown string]
 $circe2_design = "*"
 [undefined] $beam_events_file = [unknown string]
 [undefined] $job_id = [unknown string]
 [undefined] $compile_workspace = [unknown string]
 $model_name = "QED"
 $method = "omega"
 $restrictions = ""
 $omega_flags = ""
 $library_name = "show_4_lib"
 $rng_method = "tao"
 $event_file_version = ""
 $polarization_mode = "helicity"
 $out_file = ""
 $integration_method = "vamp"
 $run_id = ""
 [undefined] $integrate_workspace = [unknown string]
 $phs_method = "default"
 $phs_file = ""
 $obs_label = ""
 $obs_unit = ""
 $title = ""
 $description = ""
 $x_label = ""
 $y_label = ""
 $gmlcode_bg = ""
 $gmlcode_fg = ""
 [undefined] $fill_options = [unknown string]
 [undefined] $draw_options = [unknown string]
 [undefined] $err_options = [unknown string]
 [undefined] $symbol = [unknown string]
 $sample = ""
 $sample_normalization = "auto"
 $rescan_input_format = "raw"
 $extension_raw = "evx"
 $extension_default = "evt"
 $debug_extension = "debug"
 $dump_extension = "pset.dat"
 $extension_hepevt = "hepevt"
 $extension_ascii_short = "short.evt"
 $extension_ascii_long = "long.evt"
 $extension_athena = "athena.evt"
 $extension_mokka = "mokka.evt"
 $lhef_version = "2.0"
 $lhef_extension = "lhe"
 $extension_lha = "lha"
 $extension_hepmc = "hepmc"
 $extension_lcio = "slcio"
 $extension_stdhep = "hep"
 $extension_stdhep_up = "up.hep"
 $extension_stdhep_ev4 = "ev4.hep"
 $extension_hepevt_verb = "hepevt.verb"
 $extension_lha_verb = "lha.verb"
 $shower_method = "WHIZARD"
 $ps_PYTHIA_PYGIVE = ""
 $hadronization_method = "PYTHIA6"
 $born_me_method = ""
 $loop_me_method = ""
 $correlation_me_method = ""
 $real_tree_me_method = ""
 $dglap_me_method = ""
 $select_alpha_regions = ""
 $virtual_selection = "Full"
 $blha_ew_scheme = "alpha_qed"
 $openloops_extra_cmd = ""
 $fks_mapping_type = "default"
 $resonances_exclude_particles = "default"
 $gosam_filter_lo = ""
 $gosam_filter_nlo = ""
 $gosam_symmetries = "family,generation"
 $gosam_fc = ""
 $dalitz_plot = ""
 $nlo_correction_type = "QCD"
 $exclude_gauge_splittings = "c:b:t:e2:e3"
 $fc => Fortran-compiler
 $fcflags => Fortran-flags
 #####################################################
 ?sf_trace = false
 ?sf_allow_s_mapping = true
 ?hoppet_b_matching = false
 ?isr_recoil = false
 ?isr_keep_energy = false
 ?isr_handler = false
 ?epa_recoil = false
 ?epa_keep_energy = false
 ?epa_handler = false
 ?ewa_recoil = false
 ?ewa_keep_energy = false
 ?circe1_photon1 = false
 ?circe1_photon2 = false
 ?circe1_generate = true
 ?circe1_map = true
 ?circe1_with_radiation = false
 ?circe2_polarized = true
 ?beam_events_warn_eof = true
 ?energy_scan_normalize = false
 ?logging => true
 ?report_progress = true
 [user variable] ?me_verbose = false
 ?omega_write_phs_output = false
 ?read_color_factors = true
 ?slha_read_input = true
 ?slha_read_spectrum = true
 ?slha_read_decays = false
 ?alphas_is_fixed = true
 ?alphas_from_lhapdf = false
 ?alphas_from_pdf_builtin = false
 ?alphas_from_mz = false
 ?alphas_from_lambda_qcd = false
 ?fatal_beam_decay = true
 ?helicity_selection_active = true
 ?vis_diags = false
 ?vis_diags_color = false
 ?check_event_file = true
 ?unweighted = true
 ?negative_weights = false
 ?resonance_history = false
 ?keep_beams = false
 ?keep_remnants = true
 ?recover_beams = true
 ?update_event = false
 ?update_sqme = false
 ?update_weight = false
 ?use_alphas_from_file = false
 ?use_scale_from_file = false
 ?allow_decays = true
 ?auto_decays = false
 ?auto_decays_radiative = false
 ?decay_rest_frame = false
 ?isotropic_decay = false
 ?diagonal_decay = false
 ?polarized_events = false
+?colorize_subevt = false
 ?pacify = false
 ?out_advance = true
 ?stratified = true
 ?use_vamp_equivalences = true
 ?vamp_verbose = false
 ?vamp_history_global = true
 ?vamp_history_global_verbose = false
 ?vamp_history_channels = false
 ?vamp_history_channels_verbose = false
 ?integration_timer = true
 ?check_grid_file = true
 ?vis_channels = false
 ?check_phs_file = true
 ?phs_only = false
 ?phs_keep_nonresonant = true
 ?phs_step_mapping = true
 ?phs_step_mapping_exp = true
 ?phs_s_mapping = true
 ?vis_history = false
 ?normalize_bins = false
 ?y_log = false
 ?x_log = false
 [undefined] ?draw_histogram = [unknown logical]
 [undefined] ?draw_base = [unknown logical]
 [undefined] ?draw_piecewise = [unknown logical]
 [undefined] ?fill_curve = [unknown logical]
 [undefined] ?draw_curve = [unknown logical]
 [undefined] ?draw_errors = [unknown logical]
 [undefined] ?draw_symbols = [unknown logical]
 ?analysis_file_only = false
 ?keep_flavors_when_clustering = false
 ?sample_pacify = false
 ?sample_select = true
 ?read_raw = true
 ?write_raw = true
 ?debug_process = true
 ?debug_transforms = true
 ?debug_decay = true
 ?debug_verbose = true
 ?dump_compressed = false
 ?dump_weights = false
 ?dump_summary = false
 ?dump_screen = false
 ?hepevt_ensure_order = false
 ?lhef_write_sqme_prc = true
 ?lhef_write_sqme_ref = false
 ?lhef_write_sqme_alt = true
 ?hepmc_output_cross_section = false
 ?allow_shower = true
 ?ps_fsr_active = false
 ?ps_isr_active = false
 ?ps_taudec_active = false
 ?muli_active = false
 ?shower_verbose = false
 ?ps_isr_alphas_running = true
 ?ps_fsr_alphas_running = true
 ?ps_isr_pt_ordered = false
 ?ps_isr_angular_ordered = true
 ?ps_isr_only_onshell_emitted_partons = false
 ?allow_hadronization = true
 ?hadronization_active = false
 ?ps_tauola_photos = false
 ?ps_tauola_transverse = false
 ?ps_tauola_dec_rad_cor = true
 ?ps_tauola_pol_vector = false
 ?mlm_matching = false
 ?powheg_matching = false
 ?powheg_use_singular_jacobian = false
 ?powheg_rebuild_grids = false
 ?powheg_test_sudakov = false
 ?powheg_disable_sudakov = false
 ?ckkw_matching = false
 ?omega_openmp => false
 ?openmp_is_active* = false
 ?openmp_logging = false
 ?mpi_logging = false
 ?test_soft_limit = false
 ?test_coll_limit = false
 ?test_anti_coll_limit = false
 ?virtual_collinear_resonance_aware = true
 ?openloops_use_cms = true
 ?openloops_switch_off_muon_yukawa = false
 ?openloops_use_collier = true
 ?disable_subtraction = false
 ?vis_fks_regions = false
 ?combined_nlo_integration = false
 ?fixed_order_nlo_events = false
 ?check_event_weights_against_xsection = false
 ?keep_failed_events = false
 ?nlo_use_born_scale = true
 ?nlo_cut_all_sqmes = true
 ?nlo_use_real_partition = false
 ?rebuild_library = true
 ?recompile_library = false
 ?rebuild_phase_space = true
 ?rebuild_grids = true
 ?powheg_rebuild_grids = true
 ?rebuild_events = true
 #####################################################
 [undefined] sqrts = [unknown real]
 luminosity =  0.000000000000E+00
 ?sf_trace = false
 $sf_trace_file = ""
 ?sf_allow_s_mapping = true
 $lhapdf_dir = ""
 $lhapdf_file = ""
 $lhapdf_photon_file = ""
 lhapdf_member = 0
 lhapdf_photon_scheme = 0
 $pdf_builtin_set = "CTEQ6L"
 ?hoppet_b_matching = false
 isr_alpha =  0.000000000000E+00
 isr_q_max =  0.000000000000E+00
 isr_mass =  0.000000000000E+00
 isr_order = 3
 ?isr_recoil = false
 ?isr_keep_energy = false
 ?isr_handler = false
 $isr_handler_mode = "trivial"
 epa_alpha =  0.000000000000E+00
 epa_x_min =  0.000000000000E+00
 epa_q_min =  0.000000000000E+00
 epa_q_max =  0.000000000000E+00
 epa_mass =  0.000000000000E+00
 ?epa_recoil = false
 ?epa_keep_energy = false
 ?epa_handler = false
 $epa_handler_mode = "trivial"
 ewa_x_min =  0.000000000000E+00
 ewa_pt_max =  0.000000000000E+00
 ewa_mass =  0.000000000000E+00
 ?ewa_recoil = false
 ?ewa_keep_energy = false
 ?circe1_photon1 = false
 ?circe1_photon2 = false
 [undefined] circe1_sqrts = [unknown real]
 ?circe1_generate = true
 ?circe1_map = true
 circe1_mapping_slope =  2.000000000000E+00
 circe1_eps =  1.000000000000E-05
 circe1_ver = 0
 circe1_rev = 0
 $circe1_acc = "SBAND"
 circe1_chat = 0
 ?circe1_with_radiation = false
 ?circe2_polarized = true
 [undefined] $circe2_file = [unknown string]
 $circe2_design = "*"
 gaussian_spread1 =  0.000000000000E+00
 gaussian_spread2 =  0.000000000000E+00
 [undefined] $beam_events_file = [unknown string]
 ?beam_events_warn_eof = true
 ?energy_scan_normalize = false
 ?logging => true
 [undefined] $job_id = [unknown string]
 [undefined] $compile_workspace = [unknown string]
 seed = 0
 $model_name = "QED"
 [undefined] process_num_id = [unknown integer]
 $method = "omega"
 ?report_progress = true
 $restrictions = ""
 ?omega_write_phs_output = false
 $omega_flags = ""
 ?read_color_factors = true
 ?slha_read_input = true
 ?slha_read_spectrum = true
 ?slha_read_decays = false
 $library_name = "show_4_lib"
 ?alphas_is_fixed = true
 ?alphas_from_lhapdf = false
 ?alphas_from_pdf_builtin = false
 alphas_order = 0
 alphas_nf = 5
 ?alphas_from_mz = false
 ?alphas_from_lambda_qcd = false
 lambda_qcd =  2.000000000000E-01
 ?fatal_beam_decay = true
 ?helicity_selection_active = true
 helicity_selection_threshold =  1.000000000000E+10
 helicity_selection_cutoff = 1000
 $rng_method = "tao"
 ?vis_diags = false
 ?vis_diags_color = false
 ?check_event_file = true
 $event_file_version = ""
 n_events = 0
 event_index_offset = 0
 ?unweighted = true
 safety_factor =  1.000000000000E+00
 ?negative_weights = false
 ?resonance_history = false
 resonance_on_shell_limit =  4.000000000000E+00
 resonance_on_shell_turnoff =  0.000000000000E+00
 resonance_background_factor =  1.000000000000E+00
 ?keep_beams = false
 ?keep_remnants = true
 ?recover_beams = true
 ?update_event = false
 ?update_sqme = false
 ?update_weight = false
 ?use_alphas_from_file = false
 ?use_scale_from_file = false
 ?allow_decays = true
 ?auto_decays = false
 auto_decays_multiplicity = 2
 ?auto_decays_radiative = false
 ?decay_rest_frame = false
 ?isotropic_decay = false
 ?diagonal_decay = false
 [undefined] decay_helicity = [unknown integer]
 ?polarized_events = false
 $polarization_mode = "helicity"
+?colorize_subevt = false
 tolerance =  0.000000000000E+00
 checkpoint = 0
 event_callback_interval = 0
 ?pacify = false
 $out_file = ""
 ?out_advance = true
 real_range* = <real_range>
 real_precision* = <real_precision>
 real_epsilon* = <real_epsilon>
 real_tiny* = <real_tiny>
 $integration_method = "vamp"
 threshold_calls = 10
 min_calls_per_channel = 10
 min_calls_per_bin = 10
 min_bins = 3
 max_bins = 20
 ?stratified = true
 ?use_vamp_equivalences = true
 ?vamp_verbose = false
 ?vamp_history_global = true
 ?vamp_history_global_verbose = false
 ?vamp_history_channels = false
 ?vamp_history_channels_verbose = false
 $run_id = ""
 n_calls_test = 0
 ?integration_timer = true
 ?check_grid_file = true
 accuracy_goal =  0.000000000000E+00
 error_goal =  0.000000000000E+00
 relative_error_goal =  0.000000000000E+00
 integration_results_verbosity = 1
 error_threshold =  0.000000000000E+00
 channel_weights_power =  2.500000000000E-01
 [undefined] $integrate_workspace = [unknown string]
 $phs_method = "default"
 ?vis_channels = false
 ?check_phs_file = true
 $phs_file = ""
 ?phs_only = false
 phs_threshold_s =  5.000000000000E+01
 phs_threshold_t =  1.000000000000E+02
 phs_off_shell = 2
 phs_t_channel = 6
 phs_e_scale =  1.000000000000E+01
 phs_m_scale =  1.000000000000E+01
 phs_q_scale =  1.000000000000E+01
 ?phs_keep_nonresonant = true
 ?phs_step_mapping = true
 ?phs_step_mapping_exp = true
 ?phs_s_mapping = true
 ?vis_history = false
 n_bins = 20
 ?normalize_bins = false
 $obs_label = ""
 $obs_unit = ""
 $title = ""
 $description = ""
 $x_label = ""
 $y_label = ""
 graph_width_mm = 130
 graph_height_mm = 90
 ?y_log = false
 ?x_log = false
 [undefined] x_min = [unknown real]
 [undefined] x_max = [unknown real]
 [undefined] y_min = [unknown real]
 [undefined] y_max = [unknown real]
 $gmlcode_bg = ""
 $gmlcode_fg = ""
 [undefined] ?draw_histogram = [unknown logical]
 [undefined] ?draw_base = [unknown logical]
 [undefined] ?draw_piecewise = [unknown logical]
 [undefined] ?fill_curve = [unknown logical]
 [undefined] ?draw_curve = [unknown logical]
 [undefined] ?draw_errors = [unknown logical]
 [undefined] ?draw_symbols = [unknown logical]
 [undefined] $fill_options = [unknown string]
 [undefined] $draw_options = [unknown string]
 [undefined] $err_options = [unknown string]
 [undefined] $symbol = [unknown string]
 ?analysis_file_only = false
 kt_algorithm* = 0
 cambridge_algorithm* = 1
 antikt_algorithm* = 2
 genkt_algorithm* = 3
 cambridge_for_passive_algorithm* = 11
 genkt_for_passive_algorithm* = 13
 ee_kt_algorithm* = 50
 ee_genkt_algorithm* = 53
 plugin_algorithm* = 99
 undefined_jet_algorithm* = 999
 jet_algorithm = 999
 jet_r =  0.000000000000E+00
 jet_p =  0.000000000000E+00
 jet_ycut =  0.000000000000E+00
 ?keep_flavors_when_clustering = false
 $sample = ""
 $sample_normalization = "auto"
 ?sample_pacify = false
 ?sample_select = true
 sample_max_tries = 10000
 sample_split_n_evt = 0
 sample_split_n_kbytes = 0
 sample_split_index = 0
 $rescan_input_format = "raw"
 ?read_raw = true
 ?write_raw = true
 $extension_raw = "evx"
 $extension_default = "evt"
 $debug_extension = "debug"
 ?debug_process = true
 ?debug_transforms = true
 ?debug_decay = true
 ?debug_verbose = true
 $dump_extension = "pset.dat"
 ?dump_compressed = false
 ?dump_weights = false
 ?dump_summary = false
 ?dump_screen = false
 ?hepevt_ensure_order = false
 $extension_hepevt = "hepevt"
 $extension_ascii_short = "short.evt"
 $extension_ascii_long = "long.evt"
 $extension_athena = "athena.evt"
 $extension_mokka = "mokka.evt"
 $lhef_version = "2.0"
 $lhef_extension = "lhe"
 ?lhef_write_sqme_prc = true
 ?lhef_write_sqme_ref = false
 ?lhef_write_sqme_alt = true
 $extension_lha = "lha"
 $extension_hepmc = "hepmc"
 ?hepmc_output_cross_section = false
 $extension_lcio = "slcio"
 $extension_stdhep = "hep"
 $extension_stdhep_up = "up.hep"
 $extension_stdhep_ev4 = "ev4.hep"
 $extension_hepevt_verb = "hepevt.verb"
 $extension_lha_verb = "lha.verb"
 ?allow_shower = true
 ?ps_fsr_active = false
 ?ps_isr_active = false
 ?ps_taudec_active = false
 ?muli_active = false
 $shower_method = "WHIZARD"
 ?shower_verbose = false
 $ps_PYTHIA_PYGIVE = ""
 ps_mass_cutoff =  1.000000000000E+00
 ps_fsr_lambda =  2.900000000000E-01
 ps_isr_lambda =  2.900000000000E-01
 ps_max_n_flavors = 5
 ?ps_isr_alphas_running = true
 ?ps_fsr_alphas_running = true
 ps_fixed_alphas =  0.000000000000E+00
 ?ps_isr_pt_ordered = false
 ?ps_isr_angular_ordered = true
 ps_isr_primordial_kt_width =  0.000000000000E+00
 ps_isr_primordial_kt_cutoff =  5.000000000000E+00
 ps_isr_z_cutoff =  9.990000000000E-01
 ps_isr_minenergy =  1.000000000000E+00
 ps_isr_tscalefactor =  1.000000000000E+00
 ?ps_isr_only_onshell_emitted_partons = false
 ?allow_hadronization = true
 ?hadronization_active = false
 $hadronization_method = "PYTHIA6"
 hadron_enhanced_fraction =  1.000000000000E-02
 hadron_enhanced_width =  2.000000000000E+00
 ?ps_tauola_photos = false
 ?ps_tauola_transverse = false
 ?ps_tauola_dec_rad_cor = true
 ps_tauola_dec_mode1 = 0
 ps_tauola_dec_mode2 = 0
 ps_tauola_mh =  1.250000000000E+02
 ps_tauola_mix_angle =  9.000000000000E+01
 ?ps_tauola_pol_vector = false
 ?mlm_matching = false
 mlm_Qcut_ME =  0.000000000000E+00
 mlm_Qcut_PS =  0.000000000000E+00
 mlm_ptmin =  0.000000000000E+00
 mlm_etamax =  0.000000000000E+00
 mlm_Rmin =  0.000000000000E+00
 mlm_Emin =  0.000000000000E+00
 mlm_nmaxMEjets = 0
 mlm_ETclusfactor =  2.000000000000E-01
 mlm_ETclusminE =  5.000000000000E+00
 mlm_etaclusfactor =  1.000000000000E+00
 mlm_Rclusfactor =  1.000000000000E+00
 mlm_Eclusfactor =  1.000000000000E+00
 ?powheg_matching = false
 ?powheg_use_singular_jacobian = false
 powheg_grid_size_xi = 5
 powheg_grid_size_y = 5
 powheg_grid_sampling_points = 500000
 powheg_pt_min =  1.000000000000E+00
 powheg_lambda =  2.000000000000E-01
 ?powheg_rebuild_grids = false
 ?powheg_test_sudakov = false
 ?powheg_disable_sudakov = false
 ?ckkw_matching = false
 ?omega_openmp => false
 ?openmp_is_active* = false
 openmp_num_threads_default* = 1
 openmp_num_threads = 1
 ?openmp_logging = false
 ?mpi_logging = false
 $born_me_method = ""
 $loop_me_method = ""
 $correlation_me_method = ""
 $real_tree_me_method = ""
 $dglap_me_method = ""
 ?test_soft_limit = false
 ?test_coll_limit = false
 ?test_anti_coll_limit = false
 $select_alpha_regions = ""
 $virtual_selection = "Full"
 ?virtual_collinear_resonance_aware = true
 blha_top_yukawa = -1.000000000000E+00
 $blha_ew_scheme = "alpha_qed"
 openloops_verbosity = 1
 ?openloops_use_cms = true
 openloops_phs_tolerance = 7
 openloops_stability_log = 0
 ?openloops_switch_off_muon_yukawa = false
 $openloops_extra_cmd = ""
 ?openloops_use_collier = true
 ?disable_subtraction = false
 fks_dij_exp1 =  1.000000000000E+00
 fks_dij_exp2 =  1.000000000000E+00
 fks_xi_min =  1.000000000000E-07
 fks_y_max =  1.000000000000E+00
 ?vis_fks_regions = false
 fks_xi_cut =  1.000000000000E+00
 fks_delta_zero =  2.000000000000E+00
 fks_delta_i =  2.000000000000E+00
 $fks_mapping_type = "default"
 $resonances_exclude_particles = "default"
 alpha_power = 2
 alphas_power = 0
 ?combined_nlo_integration = false
 ?fixed_order_nlo_events = false
 ?check_event_weights_against_xsection = false
 ?keep_failed_events = false
 gks_multiplicity = 0
 $gosam_filter_lo = ""
 $gosam_filter_nlo = ""
 $gosam_symmetries = "family,generation"
 form_threads = 2
 form_workspace = 1000
 $gosam_fc = ""
 mult_call_real =  1.000000000000E+00
 mult_call_virt =  1.000000000000E+00
 mult_call_dglap =  1.000000000000E+00
 $dalitz_plot = ""
 $nlo_correction_type = "QCD"
 $exclude_gauge_splittings = "c:b:t:e2:e3"
 ?nlo_use_born_scale = true
 ?nlo_cut_all_sqmes = true
 ?nlo_use_real_partition = false
 real_partition_scale =  1.000000000000E+01
 $fc => Fortran-compiler
 $fcflags => Fortran-flags
 ?rebuild_library = true
 ?recompile_library = false
 ?rebuild_phase_space = true
 ?rebuild_grids = true
 ?powheg_rebuild_grids = true
 ?rebuild_events = true
 #####################################################
 QED.ee =>  3.028600000000E-01
 QED.me =>  5.110000000000E-04
 QED.mmu =>  1.057000000000E-01
 QED.mtau =>  1.777000000000E+00
 QED.particle* = PDG(0)
 QED.E_LEPTON* = PDG(11)
 QED.e-* = PDG(11)
 QED.e1* = PDG(11)
 QED.e+* = PDG(-11)
 QED.E1* = PDG(-11)
 QED.MU_LEPTON* = PDG(13)
 QED.m-* = PDG(13)
 QED.e2* = PDG(13)
 QED.mu-* = PDG(13)
 QED.m+* = PDG(-13)
 QED.E2* = PDG(-13)
 QED.mu+* = PDG(-13)
 QED.TAU_LEPTON* = PDG(15)
 QED.t-* = PDG(15)
 QED.e3* = PDG(15)
 QED.ta-* = PDG(15)
 QED.tau-* = PDG(15)
 QED.t+* = PDG(-15)
 QED.E3* = PDG(-15)
 QED.ta+* = PDG(-15)
 QED.tau+* = PDG(-15)
 QED.PHOTON* = PDG(22)
 QED.A* = PDG(22)
 QED.gamma* = PDG(22)
 QED.photon* = PDG(22)
 QED.charged* = PDG(11, 13, 15, -11, -13, -15)
 QED.neutral* = PDG(22)
 QED.colored* = PDG()
 [undefined] sqrts = [unknown real]
 luminosity =  0.000000000000E+00
 ?sf_trace = false
 $sf_trace_file = ""
 ?sf_allow_s_mapping = true
 $lhapdf_dir = ""
 $lhapdf_file = ""
 $lhapdf_photon_file = ""
 lhapdf_member = 0
 lhapdf_photon_scheme = 0
 $pdf_builtin_set = "CTEQ6L"
 ?hoppet_b_matching = false
 isr_alpha =  0.000000000000E+00
 isr_q_max =  0.000000000000E+00
 isr_mass =  0.000000000000E+00
 isr_order = 3
 ?isr_recoil = false
 ?isr_keep_energy = false
 ?isr_handler = false
 $isr_handler_mode = "trivial"
 epa_alpha =  0.000000000000E+00
 epa_x_min =  0.000000000000E+00
 epa_q_min =  0.000000000000E+00
 epa_q_max =  0.000000000000E+00
 epa_mass =  0.000000000000E+00
 ?epa_recoil = false
 ?epa_keep_energy = false
 ?epa_handler = false
 $epa_handler_mode = "trivial"
 ewa_x_min =  0.000000000000E+00
 ewa_pt_max =  0.000000000000E+00
 ewa_mass =  0.000000000000E+00
 ?ewa_recoil = false
 ?ewa_keep_energy = false
 ?circe1_photon1 = false
 ?circe1_photon2 = false
 [undefined] circe1_sqrts = [unknown real]
 ?circe1_generate = true
 ?circe1_map = true
 circe1_mapping_slope =  2.000000000000E+00
 circe1_eps =  1.000000000000E-05
 circe1_ver = 0
 circe1_rev = 0
 $circe1_acc = "SBAND"
 circe1_chat = 0
 ?circe1_with_radiation = false
 ?circe2_polarized = true
 [undefined] $circe2_file = [unknown string]
 $circe2_design = "*"
 gaussian_spread1 =  0.000000000000E+00
 gaussian_spread2 =  0.000000000000E+00
 [undefined] $beam_events_file = [unknown string]
 ?beam_events_warn_eof = true
 ?energy_scan_normalize = false
 ?logging => true
 [undefined] $job_id = [unknown string]
 [undefined] $compile_workspace = [unknown string]
 seed = 0
 $model_name = "QED"
 [undefined] process_num_id = [unknown integer]
 $method = "omega"
 ?report_progress = true
 [user variable] ?me_verbose = false
 $restrictions = ""
 ?omega_write_phs_output = false
 $omega_flags = ""
 ?read_color_factors = true
 ?slha_read_input = true
 ?slha_read_spectrum = true
 ?slha_read_decays = false
 $library_name = "show_4_lib"
 ?alphas_is_fixed = true
 ?alphas_from_lhapdf = false
 ?alphas_from_pdf_builtin = false
 alphas_order = 0
 alphas_nf = 5
 ?alphas_from_mz = false
 ?alphas_from_lambda_qcd = false
 lambda_qcd =  2.000000000000E-01
 ?fatal_beam_decay = true
 ?helicity_selection_active = true
 helicity_selection_threshold =  1.000000000000E+10
 helicity_selection_cutoff = 1000
 $rng_method = "tao"
 ?vis_diags = false
 ?vis_diags_color = false
 ?check_event_file = true
 $event_file_version = ""
 n_events = 0
 event_index_offset = 0
 ?unweighted = true
 safety_factor =  1.000000000000E+00
 ?negative_weights = false
 ?resonance_history = false
 resonance_on_shell_limit =  4.000000000000E+00
 resonance_on_shell_turnoff =  0.000000000000E+00
 resonance_background_factor =  1.000000000000E+00
 ?keep_beams = false
 ?keep_remnants = true
 ?recover_beams = true
 ?update_event = false
 ?update_sqme = false
 ?update_weight = false
 ?use_alphas_from_file = false
 ?use_scale_from_file = false
 ?allow_decays = true
 ?auto_decays = false
 auto_decays_multiplicity = 2
 ?auto_decays_radiative = false
 ?decay_rest_frame = false
 ?isotropic_decay = false
 ?diagonal_decay = false
 [undefined] decay_helicity = [unknown integer]
 ?polarized_events = false
 $polarization_mode = "helicity"
+?colorize_subevt = false
 tolerance =  0.000000000000E+00
 checkpoint = 0
 event_callback_interval = 0
 ?pacify = false
 $out_file = ""
 ?out_advance = true
 real_range* = <real_range>
 real_precision* = <real_precision>
 real_epsilon* = <real_epsilon>
 real_tiny* = <real_tiny>
 $integration_method = "vamp"
 threshold_calls = 10
 min_calls_per_channel = 10
 min_calls_per_bin = 10
 min_bins = 3
 max_bins = 20
 ?stratified = true
 ?use_vamp_equivalences = true
 ?vamp_verbose = false
 ?vamp_history_global = true
 ?vamp_history_global_verbose = false
 ?vamp_history_channels = false
 ?vamp_history_channels_verbose = false
 $run_id = ""
 n_calls_test = 0
 ?integration_timer = true
 ?check_grid_file = true
 accuracy_goal =  0.000000000000E+00
 error_goal =  0.000000000000E+00
 relative_error_goal =  0.000000000000E+00
 integration_results_verbosity = 1
 error_threshold =  0.000000000000E+00
 channel_weights_power =  2.500000000000E-01
 [undefined] $integrate_workspace = [unknown string]
 $phs_method = "default"
 ?vis_channels = false
 ?check_phs_file = true
 $phs_file = ""
 ?phs_only = false
 phs_threshold_s =  5.000000000000E+01
 phs_threshold_t =  1.000000000000E+02
 phs_off_shell = 2
 phs_t_channel = 6
 phs_e_scale =  1.000000000000E+01
 phs_m_scale =  1.000000000000E+01
 phs_q_scale =  1.000000000000E+01
 ?phs_keep_nonresonant = true
 ?phs_step_mapping = true
 ?phs_step_mapping_exp = true
 ?phs_s_mapping = true
 ?vis_history = false
 n_bins = 20
 ?normalize_bins = false
 $obs_label = ""
 $obs_unit = ""
 $title = ""
 $description = ""
 $x_label = ""
 $y_label = ""
 graph_width_mm = 130
 graph_height_mm = 90
 ?y_log = false
 ?x_log = false
 [undefined] x_min = [unknown real]
 [undefined] x_max = [unknown real]
 [undefined] y_min = [unknown real]
 [undefined] y_max = [unknown real]
 $gmlcode_bg = ""
 $gmlcode_fg = ""
 [undefined] ?draw_histogram = [unknown logical]
 [undefined] ?draw_base = [unknown logical]
 [undefined] ?draw_piecewise = [unknown logical]
 [undefined] ?fill_curve = [unknown logical]
 [undefined] ?draw_curve = [unknown logical]
 [undefined] ?draw_errors = [unknown logical]
 [undefined] ?draw_symbols = [unknown logical]
 [undefined] $fill_options = [unknown string]
 [undefined] $draw_options = [unknown string]
 [undefined] $err_options = [unknown string]
 [undefined] $symbol = [unknown string]
 ?analysis_file_only = false
 kt_algorithm* = 0
 cambridge_algorithm* = 1
 antikt_algorithm* = 2
 genkt_algorithm* = 3
 cambridge_for_passive_algorithm* = 11
 genkt_for_passive_algorithm* = 13
 ee_kt_algorithm* = 50
 ee_genkt_algorithm* = 53
 plugin_algorithm* = 99
 undefined_jet_algorithm* = 999
 jet_algorithm = 999
 jet_r =  0.000000000000E+00
 jet_p =  0.000000000000E+00
 jet_ycut =  0.000000000000E+00
 ?keep_flavors_when_clustering = false
 $sample = ""
 $sample_normalization = "auto"
 ?sample_pacify = false
 ?sample_select = true
 sample_max_tries = 10000
 sample_split_n_evt = 0
 sample_split_n_kbytes = 0
 sample_split_index = 0
 $rescan_input_format = "raw"
 ?read_raw = true
 ?write_raw = true
 $extension_raw = "evx"
 $extension_default = "evt"
 $debug_extension = "debug"
 ?debug_process = true
 ?debug_transforms = true
 ?debug_decay = true
 ?debug_verbose = true
 $dump_extension = "pset.dat"
 ?dump_compressed = false
 ?dump_weights = false
 ?dump_summary = false
 ?dump_screen = false
 ?hepevt_ensure_order = false
 $extension_hepevt = "hepevt"
 $extension_ascii_short = "short.evt"
 $extension_ascii_long = "long.evt"
 $extension_athena = "athena.evt"
 $extension_mokka = "mokka.evt"
 $lhef_version = "2.0"
 $lhef_extension = "lhe"
 ?lhef_write_sqme_prc = true
 ?lhef_write_sqme_ref = false
 ?lhef_write_sqme_alt = true
 $extension_lha = "lha"
 $extension_hepmc = "hepmc"
 ?hepmc_output_cross_section = false
 $extension_lcio = "slcio"
 $extension_stdhep = "hep"
 $extension_stdhep_up = "up.hep"
 $extension_stdhep_ev4 = "ev4.hep"
 $extension_hepevt_verb = "hepevt.verb"
 $extension_lha_verb = "lha.verb"
 ?allow_shower = true
 ?ps_fsr_active = false
 ?ps_isr_active = false
 ?ps_taudec_active = false
 ?muli_active = false
 $shower_method = "WHIZARD"
 ?shower_verbose = false
 $ps_PYTHIA_PYGIVE = ""
 ps_mass_cutoff =  1.000000000000E+00
 ps_fsr_lambda =  2.900000000000E-01
 ps_isr_lambda =  2.900000000000E-01
 ps_max_n_flavors = 5
 ?ps_isr_alphas_running = true
 ?ps_fsr_alphas_running = true
 ps_fixed_alphas =  0.000000000000E+00
 ?ps_isr_pt_ordered = false
 ?ps_isr_angular_ordered = true
 ps_isr_primordial_kt_width =  0.000000000000E+00
 ps_isr_primordial_kt_cutoff =  5.000000000000E+00
 ps_isr_z_cutoff =  9.990000000000E-01
 ps_isr_minenergy =  1.000000000000E+00
 ps_isr_tscalefactor =  1.000000000000E+00
 ?ps_isr_only_onshell_emitted_partons = false
 ?allow_hadronization = true
 ?hadronization_active = false
 $hadronization_method = "PYTHIA6"
 hadron_enhanced_fraction =  1.000000000000E-02
 hadron_enhanced_width =  2.000000000000E+00
 ?ps_tauola_photos = false
 ?ps_tauola_transverse = false
 ?ps_tauola_dec_rad_cor = true
 ps_tauola_dec_mode1 = 0
 ps_tauola_dec_mode2 = 0
 ps_tauola_mh =  1.250000000000E+02
 ps_tauola_mix_angle =  9.000000000000E+01
 ?ps_tauola_pol_vector = false
 ?mlm_matching = false
 mlm_Qcut_ME =  0.000000000000E+00
 mlm_Qcut_PS =  0.000000000000E+00
 mlm_ptmin =  0.000000000000E+00
 mlm_etamax =  0.000000000000E+00
 mlm_Rmin =  0.000000000000E+00
 mlm_Emin =  0.000000000000E+00
 mlm_nmaxMEjets = 0
 mlm_ETclusfactor =  2.000000000000E-01
 mlm_ETclusminE =  5.000000000000E+00
 mlm_etaclusfactor =  1.000000000000E+00
 mlm_Rclusfactor =  1.000000000000E+00
 mlm_Eclusfactor =  1.000000000000E+00
 ?powheg_matching = false
 ?powheg_use_singular_jacobian = false
 powheg_grid_size_xi = 5
 powheg_grid_size_y = 5
 powheg_grid_sampling_points = 500000
 powheg_pt_min =  1.000000000000E+00
 powheg_lambda =  2.000000000000E-01
 ?powheg_rebuild_grids = false
 ?powheg_test_sudakov = false
 ?powheg_disable_sudakov = false
 ?ckkw_matching = false
 ?omega_openmp => false
 ?openmp_is_active* = false
 openmp_num_threads_default* = 1
 openmp_num_threads = 1
 ?openmp_logging = false
 ?mpi_logging = false
 $born_me_method = ""
 $loop_me_method = ""
 $correlation_me_method = ""
 $real_tree_me_method = ""
 $dglap_me_method = ""
 ?test_soft_limit = false
 ?test_coll_limit = false
 ?test_anti_coll_limit = false
 $select_alpha_regions = ""
 $virtual_selection = "Full"
 ?virtual_collinear_resonance_aware = true
 blha_top_yukawa = -1.000000000000E+00
 $blha_ew_scheme = "alpha_qed"
 openloops_verbosity = 1
 ?openloops_use_cms = true
 openloops_phs_tolerance = 7
 openloops_stability_log = 0
 ?openloops_switch_off_muon_yukawa = false
 $openloops_extra_cmd = ""
 ?openloops_use_collier = true
 ?disable_subtraction = false
 fks_dij_exp1 =  1.000000000000E+00
 fks_dij_exp2 =  1.000000000000E+00
 fks_xi_min =  1.000000000000E-07
 fks_y_max =  1.000000000000E+00
 ?vis_fks_regions = false
 fks_xi_cut =  1.000000000000E+00
 fks_delta_zero =  2.000000000000E+00
 fks_delta_i =  2.000000000000E+00
 $fks_mapping_type = "default"
 $resonances_exclude_particles = "default"
 alpha_power = 2
 alphas_power = 0
 ?combined_nlo_integration = false
 ?fixed_order_nlo_events = false
 ?check_event_weights_against_xsection = false
 ?keep_failed_events = false
 gks_multiplicity = 0
 $gosam_filter_lo = ""
 $gosam_filter_nlo = ""
 $gosam_symmetries = "family,generation"
 form_threads = 2
 form_workspace = 1000
 $gosam_fc = ""
 mult_call_real =  1.000000000000E+00
 mult_call_virt =  1.000000000000E+00
 mult_call_dglap =  1.000000000000E+00
 $dalitz_plot = ""
 $nlo_correction_type = "QCD"
 $exclude_gauge_splittings = "c:b:t:e2:e3"
 ?nlo_use_born_scale = true
 ?nlo_cut_all_sqmes = true
 ?nlo_use_real_partition = false
 real_partition_scale =  1.000000000000E+01
 $fc => Fortran-compiler
 $fcflags => Fortran-flags
 ?rebuild_library = true
 ?recompile_library = false
 ?rebuild_phase_space = true
 ?rebuild_grids = true
 ?powheg_rebuild_grids = true
 ?rebuild_events = true
 [user variable] foo = PDG(11, 13, 15)
 [user variable] bar = ( 2.000000000000E+00, 3.000000000000E+00)
 | WHIZARD run finished.
 |=============================================================================|
Index: trunk/share/doc/manual.tex
===================================================================
--- trunk/share/doc/manual.tex	(revision 8163)
+++ trunk/share/doc/manual.tex	(revision 8164)
@@ -1,17134 +1,17160 @@
 \documentclass[12pt]{book}
 % \usepackage{feynmp}
 \usepackage{microtype}
 \usepackage{graphics,graphicx}
 \usepackage{color}
 \usepackage{amsmath,amssymb}
 \usepackage[colorlinks,bookmarks,bookmarksnumbered=true]{hyperref}
 \usepackage{thophys}
 \usepackage{fancyvrb}
 \usepackage{makeidx}
 \usepackage{units}
 \usepackage{ifpdf}
 %HEVEA\pdftrue
 \makeindex
 \usepackage{url}
 \usepackage[latin1]{inputenc}
 %HEVEA\@def@charset{UTF-8}
 %BEGIN LATEX
 \usepackage{supertabular,fancyvrb}
 \usepackage{hevea}
 %END LATEX
 \renewcommand{\topfraction}{0.9}
 \renewcommand{\bottomfraction}{0.8}
 \renewcommand{\textfraction}{0.1}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%% Macro section
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \newcommand{\email}[2]{\thanks{\ahref{#1@{}#2}{#1@{}#2}}}
 \newcommand{\hepforgepage}{\url{https://whizard.hepforge.org}}
 \newcommand{\whizardwiki}{\url{https://projects.hepforge.org/whizard/trac/wiki}}
 \tocnumber
 %BEGIN LATEX
 \DeclareMathOperator{\diag}{diag}
 %END LATEX
 %BEGIN LATEX
 \makeatletter
 \newif\if@preliminary
 \@preliminaryfalse
 \def\preliminary{\@preliminarytrue}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%% Changes referring to article.cls
 %
 %%% Title page
 \def\preprintno#1{\def\@preprintno{#1}}
 \def\address#1{\def\@address{#1}}
 \def\email#1#2{\thanks{\tt #1@{}#2}}
 \def\abstract#1{\def\@abstract{#1}}
 \newcommand\abstractname{ABSTRACT}
 \newlength\preprintnoskip
 \setlength\preprintnoskip{\textwidth\@plus -1cm}
 \newlength\abstractwidth
 \setlength\abstractwidth{\textwidth\@plus -3cm}
 %
 \@titlepagetrue
 \renewcommand\maketitle{\begin{titlepage}%
   \let\footnotesize\small
   \hfill\parbox{\preprintnoskip}{%
   \begin{flushright}\@preprintno\end{flushright}}\hspace*{1cm}
   \vskip 60\p@
   \begin{center}%
     {\Large\bf\boldmath \@title \par}\vskip 1cm%
     {\sc\@author \par}\vskip 3mm%
     {\@address \par}%
     \if@preliminary
       \vskip 2cm {\large\sf PRELIMINARY DRAFT \par \@date}%
     \fi
   \end{center}\par
   \@thanks
   \vfill
   \begin{center}%
     \parbox{\abstractwidth}{\centerline{\abstractname}%
     \vskip 3mm%
     \@abstract}
   \end{center}
   \end{titlepage}%
   \setcounter{footnote}{0}%
   \let\thanks\relax\let\maketitle\relax
   \gdef\@thanks{}\gdef\@author{}\gdef\@address{}%
   \gdef\@title{}\gdef\@abstract{}\gdef\@preprintno{}
 }%
 %
 %%% New settings of dimensions
 \topmargin -1.5cm
 \textheight 22cm
 \textwidth 17cm
 \oddsidemargin 0cm
 \evensidemargin 0cm
 %
 %%% Original Latex definition of citex, except for the removal of
 %%% 'space' following a ','. \citerange replaces the ',' by '--'.
 \def\@citex[#1]#2{\if@filesw\immediate\write\@auxout{\string\citation{#2}}\fi
   \def\@citea{}\@cite{\@for\@citeb:=#2\do
     {\@citea\def\@citea{,\penalty\@m}\@ifundefined
        {b@\@citeb}{{\bf ?}\@warning
        {Citation `\@citeb' on page \thepage \space undefined}}%
 \hbox{\csname b@\@citeb\endcsname}}}{#1}}
 \def\citerange{\@ifnextchar [{\@tempswatrue\@citexr}{\@tempswafalse\@citexr[]}}
 \def\@citexr[#1]#2{\if@filesw\immediate\write\@auxout{\string\citation{#2}}\fi
   \def\@citea{}\@cite{\@for\@citeb:=#2\do
     {\@citea\def\@citea{--\penalty\@m}\@ifundefined
        {b@\@citeb}{{\bf ?}\@warning
        {Citation `\@citeb' on page \thepage \space undefined}}%
 \hbox{\csname b@\@citeb\endcsname}}}{#1}}
 %
 %%% Captions set in italics
 \long\def\@makecaption#1#2{%
   \vskip\abovecaptionskip
   \sbox\@tempboxa{#1: \emph{#2}}%
   \ifdim \wd\@tempboxa >\hsize
     #1: \emph{#2}\par
   \else
     \hbox to\hsize{\hfil\box\@tempboxa\hfil}%
   \fi
   \vskip\belowcaptionskip}
 %
 %%% Other useful macros
 \def\fmslash{\@ifnextchar[{\fmsl@sh}{\fmsl@sh[0mu]}}
 \def\fmsl@sh[#1]#2{%
   \mathchoice
     {\@fmsl@sh\displaystyle{#1}{#2}}%
     {\@fmsl@sh\textstyle{#1}{#2}}%
     {\@fmsl@sh\scriptstyle{#1}{#2}}%
     {\@fmsl@sh\scriptscriptstyle{#1}{#2}}}
 \def\@fmsl@sh#1#2#3{\m@th\ooalign{$\hfil#1\mkern#2/\hfil$\crcr$#1#3$}}
 \makeatother
 
 % Labelling command for Feynman graphs generated by package FEYNMF
 %\def\fmfL(#1,#2,#3)#4{\put(#1,#2){\makebox(0,0)[#3]{#4}}}
 
 %END LATEX
 %%%% Environment for showing user input and program response
 \newenvironment{interaction}%
   {\begingroup\small
    \Verbatim}%
   {\endVerbatim
    \endgroup\noindent}
 %BEGIN LATEX
 
 %%%% Environment for typesetting listings verbatim
 \newenvironment{code}%
   {\begingroup\footnotesize
    \quote
    \Verbatim}%
   {\endVerbatim
    \endquote
    \endgroup\noindent}
 
 %%%% Boxed environment for typesetting listings verbatim
 \newenvironment{Code}%
   {\begingroup\footnotesize
    \quote
    \Verbatim[frame=single]}%
   {\endVerbatim
    \endquote
    \endgroup\noindent}
 
 %%% Environment for displaying syntax
 \newenvironment{syntax}%
   {\begin{quote}
    \begin{flushleft}\tt}%
   {\end{flushleft}
    \end{quote}}
 \newcommand{\var}[1]{$\langle$\textit{#1}$\rangle$}
 
 
 %END LATEX
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % Macros specific for this paper
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \newcommand{\ttt}[1]{\texttt{#1}}
 \newcommand{\whizard}{\ttt{WHIZARD}}
 \newcommand{\oMega}{\ttt{O'Mega}}
 \newcommand{\vamp}{\ttt{VAMP}}
 \newcommand{\vamptwo}{\ttt{VAMP2}}
 \newcommand{\vegas}{\ttt{VEGAS}}
 \newcommand{\madgraph}{\ttt{MadGraph}}
 \newcommand{\CalcHep}{\ttt{CalcHep}}
 \newcommand{\helas}{\ttt{HELAS}}
 \newcommand{\herwig}{\ttt{HERWIG}}
 \newcommand{\isajet}{\ttt{ISAJET}}
 \newcommand{\pythia}{\ttt{PYTHIA}}
 \newcommand{\pythiasix}{\ttt{PYTHIA6}}
 \newcommand{\pythiaeight}{\ttt{PYTHIA8}}
 \newcommand{\jetset}{\ttt{JETSET}}
 \newcommand{\comphep}{\ttt{CompHEP}}
 \newcommand{\circe}{\ttt{CIRCE}}
 \newcommand{\circeone}{\ttt{CIRCE1}}
 \newcommand{\circetwo}{\ttt{CIRCE2}}
 \newcommand{\gamelan}{\textsf{gamelan}}
 \newcommand{\stdhep}{\ttt{STDHEP}}
 \newcommand{\lcio}{\ttt{LCIO}}
 \newcommand{\pdflib}{\ttt{PDFLIB}}
 \newcommand{\lhapdf}{\ttt{LHAPDF}}
 \newcommand{\hepmc}{\ttt{HepMC}}
 \newcommand{\fastjet}{\ttt{FastJet}}
 \newcommand{\hoppet}{\ttt{HOPPET}}
 \newcommand{\metapost}{\ttt{MetaPost}}
 \newcommand{\sarah}{\ttt{SARAH}}
 \newcommand{\spheno}{\ttt{SPheno}}
 \newcommand{\Mathematica}{\ttt{Mathematica}}
 \newcommand{\FeynRules}{\ttt{FeynRules}}
 \newcommand{\UFO}{\ttt{UFO}}
 \newcommand{\gosam}{\ttt{Gosam}}
 \newcommand{\openloops}{\ttt{OpenLoops}}
 \newcommand{\recola}{\ttt{Recola}}
 \newcommand{\collier}{\ttt{Collier}}
 \newcommand{\powheg}{\ttt{POWHEG}}
 %%%%%
 \newcommand{\sindarin}{\ttt{SINDARIN}}
 \newcommand{\cpp}{\ttt{C++}}
 \newcommand{\fortran}{\ttt{Fortran}}
 \newcommand{\fortranSeventySeven}{\ttt{FORTRAN77}}
 \newcommand{\fortranNinetyFive}{\ttt{Fortran95}}
 \newcommand{\fortranOThree}{\ttt{Fortran2003}}
 \newcommand{\ocaml}{\ttt{OCaml}}
 \newcommand{\python}{\ttt{Python}}
 
 \newenvironment{commands}{\begin{quote}\tt}{\end{quote}}
 \newcommand{\eemm}{$e^+e^- \to \mu^+\mu^-$}
 
 %\def\~{$\sim$}
 \newcommand{\sgn}{\mathop{\rm sgn}\nolimits}
 \newcommand{\GeV}{\textrm{GeV}}
 \newcommand{\fb}{\textrm{fb}}
 \newcommand{\ab}{\textrm{ab}}
 
 \newenvironment{parameters}{%
 \begin{center}
 \begin{tabular}{lccp{65mm}}
 \hline
 Parameter & Value & Default & Description \\
 \hline
 }{%
 \hline
 \end{tabular}
 \end{center}
 }
 
 \newenvironment{options}{%
 \begin{center}
 \begin{tabular}{llcp{80mm}}
 \hline
 Option & Long version & Value & Description \\
 \hline
 }{%
 \hline
 \end{tabular}
 \end{center}
 }
 
 %BEGIN LATEX
 \renewenvironment{options}{%
 \begin{center}
 \tablehead{\hline
 Option & Long version & Value & Description \\
 \hline
 }
 \begin{supertabular}{llcp{80mm}}
 }{%
 \hline
 \end{supertabular}
 \end{center}
 }
 %END LATEX
 
 %BEGIN LATEX
 \renewenvironment{parameters}{%
 \begin{center}
 \tablehead{\hline
 Parameter & Value & Default & Description \\
 \hline
 }
 \begin{supertabular}{lccp{65mm}}
 }{%
 \hline
 \end{supertabular}
 \end{center}
 }
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %END LATEX
 \newcommand{\thisversion}{2.6.4}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \begin{document}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %BEGIN LATEX
 \preprintno{}
 %%%\preprintno{arXiv:0708.4233 (also based on LC-TOOL-2001-039 (revised))}
 %END LATEX
 \title{%
 %HEVEA WHIZARD 2.6 \\
 %BEGIN LATEX
  \ttt{\huge WHIZARD 2.6} \\[\baselineskip]
 %END LATEX
  A generic \\ Monte-Carlo integration and event generation package \\
  for multi-particle processes\\[\baselineskip]
  MANUAL
  \footnote{%
  This work is supported by Helmholtz-Alliance ``Physics at the
  Terascale''.
  In former stages this work has also been supported by
  the Helmholtz-Gemeinschaft VH--NG--005 \\
  E-mail: \ttt{whizard@desy.de}
  }
  \\[\baselineskip]
 }
 % \def\authormail{\ttt{kilian@physik.uni-siegen.de},
 %   \ttt{ohl@physik.uni-wuerzburg.de},
 %   \ttt{juergen.reuter@desy.de}, \ttt{cnspeckn@googlemail.com}}
 \author{%
   Wolfgang Kilian,%
   Thorsten Ohl,%
   J\"urgen Reuter,%
   with contributions from
   Fabian Bach, %
   Simon Bra\ss,
   Bijan Chokouf\'{e} Nejad, %
   Christian Fleper, %
   Vincent Rothe, %
   Sebastian Schmidt, %
   Marco Sekulla, %
   Christian Speckner, %
   So Young Shim, %
   Florian Staub, %
   Christian Weiss}
 
 %BEGIN LATEX
 \address{%
  Universit\"at Siegen, Emmy-Noether-Campus, Walter-Flex-Str. 3,
  D--57068 Siegen, Germany \\
  Universit\"at W\"urzburg, Emil-Hilb-Weg 22,
  D--97074 W\"urzburg, Germany \\
  Deutsches Elektronen-Synchrotron DESY, Notkestr. 85,
  D--22603 Hamburg, Germany \\
  %% \authormail
  \vspace{1cm}
  \begin{center}
  \includegraphics[width=4cm]{Whizard-Logo}
  \end{center}
  \mbox{} \\
  \vspace{2cm}
  \mbox{} when using \whizard\ please cite: \\
  W. Kilian, T. Ohl, J. Reuter, \\ {\em WHIZARD: Simulating Multi-Particle
  Processes at LHC and ILC}, \\
  Eur.Phys.J.{\bf C71} (2011) 1742, arXiv:
  0708.4233 [hep-ph]; \\
  M. Moretti, T. Ohl, J. Reuter, \\ {\em O'Mega: An Optimizing Matrix
  Element Generator}, \\
  arXiv: hep-ph/0102195
 }
 %END LATEX
 %BEGIN LATEX
 \abstract{%
 \whizard\ is a program system designed for the efficient calculation
 of multi-particle scattering cross sections and simulated event
 samples.  The generated events can be written to file in various formats
 (including HepMC, LHEF, STDHEP, LCIO, and ASCII) or analyzed directly on the
 parton or hadron level using a built-in \LaTeX-compatible graphics
 package.
 \\[\baselineskip]
 Complete tree-level matrix elements are generated automatically for arbitrary
 partonic multi-particle processes by calling the built-in matrix-element
 generator \oMega.  Beyond hard matrix elements, \whizard\ can generate
 (cascade) decays with complete spin correlations.
 Various models beyond the SM are implemented, in particular,
 the MSSM is supported with an interface to the SUSY Les Houches Accord
 input format.  Matrix elements obtained by alternative methods (e.g.,
 including loop corrections) may be interfaced as well.
 \\[\baselineskip]
 The program uses an adaptive multi-channel method for phase space
 integration, which allows to calculate numerically stable signal and
 background cross sections and generate unweighted event samples with
 reasonable efficiency for processes with up to eight and more
 final-state particles.  Polarization is treated exactly for both the
 initial and final states.  Quark or lepton flavors can be
 summed over automatically where needed.
 \\[\baselineskip]
 For hadron collider physics, we ship the package with the most recent
 PDF sets from the MSTW/MMHT and CTEQ/CT10/CJ12/CJ15/CT14
 collaborations. Furthermore, an interface to the \lhapdf\ library is
 provided.
 \\[\baselineskip]
 For Linear Collider physics,
 beamstrahlung (\circeone, \circetwo), Compton and ISR spectra are
 included for electrons and photons, including the most recent ILC and
 CLIC collider designs. Alternatively, beam-crossing events can be read
 directly from file.
 \\[\baselineskip]
 For parton showering and matching/merging with hard matrix elements ,
 fragmenting and hadronizing the final state, a first version of two
 different parton shower algorithms are included in the \whizard\
 package. This also includes infrastructure for the MLM matching and
 merging algorithm. For hadronization and hadronic decays, \pythia\
 and \herwig\ interfaces are provided which follow the Les Houches
 Accord. In addition, the last and final version of (\fortran) \pythia\
 is included in the package.
 \\[\baselineskip]
 The \whizard\ distribution is available at
 %%% \begin{center}
 %%%   \ttt{http://whizard.event-generator.org}
 %%% \end{center}
 %%% or at
 \begin{center}
   \url{https://projects.hepforge.org/whizard}
 \end{center}
 where also the \ttt{svn} repository is located.
 }
 %END LATEX
 %
 \maketitle
 
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%% Text
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %\begin{fmffile}
 \tableofcontents
 
 \newpage
 \chapter{Introduction}
 
 \section{Disclaimer}
 
 \emph{This is a preliminary version of the WHIZARD manual.  Many parts
   are still missing or incomplete, and some parts will be rewritten and
   improved soon.  To find updated versions of the manual,
   visit the \whizard\ website}
 \begin{center}
   \hepforgepage
 \end{center}
 \emph{or consult the current version in the \ttt{svn} repository
   on \hepforgepage\ directly. Note, that the most recent version of
   the manual might contain information about features of the
   current \ttt{svn} version, which are not contained in the last
   official release version!}
 
 \emph{For information that is not (yet) written in the manual, please
 consult the examples in the \whizard\ distribution.  You will find these in
 the subdirectory \ttt{share/examples} of the main directory where
 \whizard\ is installed. More information about the examples can be
 found on the \whizard\ Wiki page}
 \begin{center}
   \whizardwiki .
 \end{center}
 
 %%%%%
 
 \clearpage
 \section{Overview}
 
 \whizard\ is a multi-purpose event generator that covers all parts of
 event generation (unweighted and weighted), either through intrinsic
 components or interfaces to external packages. Realistic collider
 environments are covered through sophisticated descriptions for beam
 structures at hadron colliders, lepton colliders, lepton-hadron
 colliders, both circular and linear machines. Other options include
 scattering processes e.g. for dark matter annihilation or particle
 decays. \whizard\ contains its in-house generator for (tree-level)
 high-multiplicity matrix elements, \oMega\, that supports the whole
 Standard Model (SM) of particle physics and basically all possibile
 extensions of it. QCD parton shower describe high-multiplicity
 partonic jet events that can be matched with matrix elements. At the
 moment, only hadron collider parton distribution functions (PDFs) and
 hadronization are handled by packages not written by the main
 authors.
 
 This manual is organized mainly along the lines of the way how to run
 \whizard: this is done through a command language, \sindarin\ (Scripting
 INtegration, Data Analysis, Results display and INterfaces.) Though
 this seems a complication at first glance, the user is rewarded with a
 large possibility, flexibility and versatility on how to steer
 \whizard.
 
 After some general remarks in the follow-up sections, in
 Chap.~\ref{chap:installation} we describe how to get the program, the
 package structure, the prerequisites, possible external extensions of
 the program and the basics of the installation (both as superuser and
 locally). Also, a first technical overview how to work with \whizard\
 on single computer, batch clusters and farms are given. Furthermore,
 some rare uncommon possible build problems are discussed, and a tour
 through options for debugging, testing and validation is being made.
 
 A first dive into the running of the program is made in
 Chap.~\ref{chap:start}. This is following by an extensive, but rather
 technical introduction into the steering language \sindarin\ in
 Chap.~\ref{chap:sindarinintro}. Here, the basic elements of the
 language like commands, statements, control structures, expressions
 and variables as well as the form of warnings and error messages are
 explained in detail.
 
 Chap.~\ref{chap:sindarin} contains the application of the \sindarin\
 command language to the main tasks in running \whizard\ in a physics
 framework: the defintion of particles, subevents, cuts, and event
 selections. The specification of a particular physics models is
 \begin{figure}[t]
   \centering
   \includegraphics[width=0.9\textwidth]{whizstruct}
   \caption{General structure of the \whizard\ package.}
 \end{figure}
 discussed, while the next sections are devoted to the setup and
 compilation of code for particular processes, the specification of
 beams, beam structure and polarization. The next step is the
 integration, controlling the integration, phase space, generator cuts,
 scales and weights, proceeding further to event generation and
 decays. At the end of this chapter, \whizard's internal data analysis
 methods and graphical visualization options are documented.
 
 The following chapters are dedicated to the physics implemented in
 \whizard: methods for hard matrix interactions in
 Chap.~\ref{chap:hardint}. Then, in Chap.~\ref{chap:physics},
 implemented methods for adaptive multi-channel integration,
 particularly the integrator \vamp\ are explained, together with the
 algorithms for the generation of the phase-space in \whizard. Finally,
 an overview is given over the physics models implemented in \whizard\
 and its matrix element generator \oMega, together with possibilities
 for their extension. After that, the next chapter discusses parton
 showering, matching and hadronization as well as options for event
 normalizations and supported event formats. Also weighted event
 generation is explained along the lines with options for negative
 weights. Then, in Chap.~\ref{chap:user}, options for user to plug-in
 self-written code into the \whizard\ framework are detailed, e.g. for
 observables, selections and cut functions, or for spectra and
 structure functions. Also, static executables are discussed.
 
 Chap.~\ref{chap:visualization} is a stand-alone documentation of
 GAMELAN, the interal graphics support for the visualization of data
 and analysis. The next chapter, Chap.~\ref{chap:userint} details user
 interfaces: how to use more options of the \whizard\ command on the
 command line, how to use \whizard\ interactively, and how to include
 \whizard\ as a library into the user's own program.
 
 Then, an extensive list of examples in Chap.~\ref{chap:examples}
 documenting physics examples from the LEP, SLC, HERA, Tevatron, and
 LHC colliders to future linear and circular colliders. This chapter is
 a particular good reference for the beginning, as the whole chain from
 choosing a model, setting up processes, the beam structure, the
 integration, and finally simulation and (graphical) analysis are
 explained in detail.
 
 More technical details about efficiency, tuning and advance usage of
 \whizard\ are collected in Chap.~\ref{chap:tuning}. Then,
 Chap.~\ref{chap:extmodels} shows how to set up your own new physics
 model with the help of external programs like \sarah\ or
 \FeynRules\ program or the Universal Feynrules Output, UFO, and
 include it into the \whizard\ event generator.
 
 In the appendices, we e.g. give an exhaustive reference list of
 \sindarin\ commands and built-in variables.
 
 Please report any inconsistencies, bugs, problems or simply pose open
 questions to our contact \url{whizard@desy.de}.
 
 
 %%%%%
 
 \section{Historical remarks}
 
 This section gives a historical overview over the development of
 \whizard\ and can be easily skipped in a (first) reading of the
 manual. \whizard\ has been developed in a first place as a tool for
 the physics at the then planned linear electron-positron collider
 TESLA around 1999. The intention was to have a tool at hand to
 describe electroweak physics of multiple weak bosons and the Higgs
 boson as precise as possible with full matrix elements. Hence, the
 acronym: \ttt{WHiZard}, which stood for $\mathbf{W}$, {\bf H}iggs,
 $\mathbf{Z}$, {\bf a}nd {\bf r}espective {\bf d}ecays.
 
 Several components of the \whizard\ package that are also available as
 independent sub-packages have been published already before the first
 versions of the \whizard\ generator itself: the multi-channel adaptive
 Monte-Carlo integration package \vamp\ has been released mid
 1998~\cite{VAMP}. The dedicated packages for the simulation of linear
 lepton collider beamstrahlung and the option for a photon collider on
 Compton backscattering (\ttt{CIRCE1/2}) date back even to mid
 1996~\cite{CIRCE}. Also parts of the code for \whizard's internal
 graphical analysis (the \gamelan\ module) came into existence already
 around 1998.
 
 After first inofficial versions, the official version 1 of \whizard\
 was release in the year 2000. The development, improvement and
 incorporation of new features continued for roughly a decade. Major
 milestones in the development were the full support of all kinds of
 beyond the Standard Model (BSM) models including spin 3/2 and spin 2
 particles and the inclusion of the MSSM, the NMSSM, Little Higgs
 models and models for anomalous couplings as well as extra-dimensional
 models from version 1.90 on. In the beginning, several methods for
 matrix elements have been used, until the in-house matrix element
 generator \oMega\ became available from version 1.20 on. It was
 included as a part of the \whizard\ package from version 1.90 on. The
 support for full color amplitudes came with version 1.50, but in a
 full-fledged version from 2.0 on. Version 1.40 brought the necessary
 setups for all kinds of collider environments, i.e. asymmetric beams,
 decay processes, and intrinsic $p_T$ in structure functions.
 
 Version 2.0 was released in April 2010 as an almost complete rewriting
 of the original code. It brought the construction of an internal
 density-matrix formalism which allowed the use of factorized
 production and (cascade) decay processes including complete color and
 spin correlations. Another big new feature was the command-line
 language \sindarin\ for steering all parts of the program. Also, many
 performance improvement have taken place in the new release series,
 like OpenMP parallelization, speed gain in matrix element generation
 etc. Version 2.2 came out in May 2014 as a major refactoring of the
 program internals but keeping (almost everywhere) the same user
 interface. New features are inclusive processes, reweighting, and more
 interfaces for QCD environments (BLHA/HOPPET).
 
 The following tables shows some of the major steps (physics
 implementation and/or technical improvements) in the development
 of \whizard:
 
 \begin{center}
 \begin{tabular}{|l|l|l|}\hline
   0.99 & 08/1999 & Beta version \\\hline
   1.00 & 12/2000 & First public version \\\hline
   1.10 & 03/2001 & Libraries; \pythiasix\ interface \\
   1.11 & 04/2001 & PDF support; anomalous couplings \\ \hline
   1.20 & 02/2002 & \oMega\ matrix elements; \ttt{CIRCE} support\\
   1.22 & 03/2002 & QED ISR; beam remnants, phase space improvements \\
   1.25 & 05/2003 & MSSM; weighted events; user-code plug-in \\
   1.28 & 04/2004 & Improved phase space; SLHA interface; signal catching
   \\\hline
   1.30 & 09/2004 & Major technical overhaul \\\hline
   1.40 & 12/2004 & Asymmetric beams; decays; $p_T$ in structure
   functions \\\hline
   1.50 & 02/2006 & QCD support in \oMega\ (color flows); LHA format \\
   1.51 & 06/2006 & $Hgg$, $H\gamma\gamma$; Spin 3/2 + 2; BSM models
   \\\hline
   1.90 & 11/2007 & \oMega\ included; LHAPDF support; $Z'$; $WW$ scattering \\
   1.92 & 03/2008 & LHE format; UED; parton shower beta version \\
   1.93 & 04/2009 & NMSSM; SLHA2 accord; improved color/flavor sums \\
   1.95 & 02/2010 & MLM matching; development stop in version 1
   \\
   1.97 & 05/2011 & Manual for version 1 completed. \\\hline\hline
   2.0.0 & 04/2010 & Major refactoring: automake setup; dynamic
   libraries \\
   & & improved speed; cascades; OpenMP; \sindarin\ steering language \\
   2.0.3 & 07/2010 & QCD ISR+FSR shower; polarized beams \\
   2.0.5 & 05/2011 & Builtin PDFs; static builds; relocation scripts \\
   2.0.6 & 12/2011 & Anomalous top couplings; unit tests \\\hline
   2.1.0 & 06/2012 & Analytic ISR+FSR parton shower; anomalous Higgs
   couplings \\\hline
   2.2.0 & 05/2014 & Major technical refactoring: abstract
   object-orientation; THDM; \\
   & & reweighting; LHE v2/3; BLHA; HOPPET interface; inclusive
   processes \\
   2.2.1 & 05/2014 & CJ12 PDFs; FastJet interface \\
   2.2.2 & 07/2014 & LHAPDF6 support; correlated LC beams; GuineaPig
   interface \\
   2.2.3 & 11/2014 & O'Mega virtual machine; lepton collider top
   pair threshold; Higgs singlet extension \\
   2.2.4 & 02/2015 & LCIO support; progress on NLO; many technical
   bug fixes \\
   2.2.7 & 08/2015 & progress on POWHEG; fixed-order NLO events;
   revalidation of ILC event chain \\
   2.2.8 & 11/2015 & support for quadruple precision; StdHEP included;
   SM dim 6 operators supported
   \\\hline
   2.3.0 & 07/2016 & NLO: resonance mappings for FKS subtraction; more
   advanced cascade syntax; \\
   & & GUI ($\alpha$ version); UFO support
   ($\alpha$ version); ILC v1.9x-v2.x final validation \\
   2.3.1 & 08/2016 & Complex mass scheme
   \\\hline
   2.4.0 & 11/2016 & Refactoring of NLO setup \\
   2.4.1 & 03/2017 & $\alpha$ version of new VEGAS implementation
   \\\hline
   2.5.0 & 05/2017 & Full UFO support (SM-like models)
   \\\hline
   2.6.0 & 09/2017 & MPI parallel integration and event generation;
   resonance histories \\
   & & for showers; RECOLA support \\
   2.6.1 & 11/2017 & EPA/ISR transverse distributions, handling of
   shower resonances; \\
   & & more efficient (alternative) phase space generation \\
   2.6.2 & 12/2017 & $Hee$ coupling, improved resonance matching \\
   2.6.3 & 02/2018 & Partial NLO refactoring for quantum numbers,
   unified RECOLA 1/2 interface. \\
   2.6.4. & 08/2018 & Bug fixes: color flows, HSExt model
   \\\hline
 \end{tabular}
 \end{center}
 
 \vspace{.5cm}
 
 For a detailed overview over the historical development of the code
 confer the \ttt{ChangeLog} file and the commit messages in our
 revision control system repository.
 
 %%%%%
 
 \section{About examples in this manual}
 
 Although \whizard\ has been designed as a Monte Carlo event generator
 for LHC physics, several elementary steps and aspects of its usage
 throughout the manual will be demonstrated with the famous textbook
 example of $e^+e^- \to \mu^+ \mu^-$. This is the same process, the
 textbook by Peskin/Schroeder \cite{PeskinSchroeder} uses as a prime
 example to teach the basics of quantum field theory. We use this
 example not because it is very special for \whizard\ or at the time
 being a relevant physics case, but simply because it is the easiest
 fundamental field theoretic process without the complications of
 structured beams (which can nevertheless be switched on like for ISR
 and beamstrahlung!), the need for jet definitions/algorithms and
 flavor sums; furthermore, it easily accomplishes a demonstration of
 polarized beams. After the basics of \whizard\ usage have been
 explained, we move on to actual physics cases from LHC (or Tevatron).
 
 
 \newpage
 \chapter{Installation}
 \label{chap:installation}
 
 \section{Package Structure}
 
 \whizard\ is a software package that consists of a main executable
 program (which is called \ttt{whizard}), libraries, auxiliary
 executable programs, and machine-independent data files.  The whole
 package can be installed by the system administrator, by default, on a
 central location in the file system (\ttt{/usr/local} with its proper
 subdirectories).  Alternatively, it is possible to install it in a
 user's home directory, without administrator privileges, or at any
 other location.
 
 A \whizard\ run requires a workspace, i.e., a writable directory where
 it can put generated code and data.  There are no constraints on the
 location of this directory, but we recommend to use a separate
 directory for each \whizard\ project, or even for each \whizard\ run.
 
 Since \whizard\ generates the matrix elements for scattering and decay
 processes in form of \fortran\ code that is automatically compiled and
 dynamically linked into the running program, it requires a working
 \fortran\ compiler not just for the installation, but also at runtime.
 
 The previous major version \whizard1 did put more constraints on the
 setup.  In a nutshell, not just the matrix element code was compiled
 at runtime, but other parts of the program as well, so the whole
 package was interleaved and had to be installed in user space.  The
 workflow was controlled by \ttt{make} and PERL scripts.  These
 constraints are gone in the present version in favor of a clean
 separation of installation and runtime workspace.
 
 
 \section{\label{sec:prerequisites}Prerequisites}
 
 \subsection{No Binary Distribution}
 
 \whizard\ is currently not distributed as a binary package, nor is it
 available as a debian or RPM package.  This might change in the
 future.  However, compiling from source is very simple (see below).
 Since the package needs a compiler also at runtime, it would not work
 without some development tools installed on the machine, anyway.
 
 Note, however, that we support an install script, that downloads all
 necessary prerequisites, and does the configuration and compilation
 described below automatically. This is called the ``instant WHIZARD''
 and is accessible through the WHIZARD webpage from version 2.1.1 on:
 \url{https://whizard.hepforge.org/versions/install/install-whizard-2.X.X.sh}.
 Download this shell script, make it executable by
 \begin{interaction}
   chmod +x install-whizard-2.X.X.sh
 \end{interaction}
 and execute it. Note that this also involves compilation of the
 required \ttt{Fortran} compiler which takes 1-3 hours depending on
 your system.
 \ttt{Darwin} operating systems (a.k.a. as \ttt{Mac OS X}) have a very
 similar general system for all sorts of software, called
 \ttt{MacPorts} (\url{http://www.macports.org}). This offers to install
 \whizard\ as one of its software ports, and is very similar to
 ``instant WHIZARD'' described above.
 
 
 \subsection{Tarball Distribution}
 
 This is the recommended way of obtaining \whizard.  You may download
 the current stable distribution from the \whizard\ webpage,
 hosted at the HepForge webpage
 \begin{quote}
   \hepforgepage
 \end{quote}
 The distribution is a single file, say \ttt{whizard-\thisversion.tgz} for
 version \thisversion.
 
 You need the additional prerequisites:
 \begin{itemize}
 \item
   GNU \ttt{tar} (or \ttt{gunzip} and \ttt{tar}) for unpacking the
   tarball.
 \item
   The \ttt{make} utility.  Other standard Unix utilities (\ttt{sed},
   \ttt{grep}, etc.) are usually installed by default.
 \item
   A modern \fortran\ compiler (see Sec.~\ref{sec:compilers} for
   details).
 \item
   The \ocaml\ system.  \ocaml\ is a functional and object-oriented
   language.  Version 3.12 or later is required to compile all components
   of \whizard. The package is freely available either as a debian/RPM package
   on your system (it might be necessary to install it from the usual
   repositories), or you can obtain it directly from
   \begin{quote}
     \url{http://caml.inria.fr}
   \end{quote}
   and install it yourself.  If desired, the package can be installed
   in user space without administrator privileges\footnote{
     Unfortunately, the version of the \ocaml\
     compiler from 3.12.0 broke backwards compatibility. Therefore,
     versions of \oMega/\whizard\ up to 2.0.2 only compile with older
     versions (3.11.x works). This has been fixed in versions
     2.0.3 and later. See also Sec.~\ref{sec:buildproblems}.}.
 \end{itemize}
 The following optional external packages are not required, but used
 for certain purposes.  Make sure to check whether you will need any of
 them, before you install \whizard.
 \begin{itemize}
 \item
   \LaTeX\ and \metapost\ for data visualization.  Both are part of the
   \TeX\ program family.  These programs are not absolutely necessary,
   but \whizard\ will lack the tools for visualization without them.
 \item
   The \lhapdf\ structure-function library.  See
   Sec.~\ref{sec:lhapdf_install}.
 \item
   The \hoppet\ structure-function matching tool. See
   Sec.~\ref{sec:hoppet}.
 \item
   The \hepmc\ event-format package.  See Sec.~\ref{sec:hepmc}.
 \item
   The \fastjet\ jet-algorithm package.  See Sec.~\ref{sec:fastjet}.
 \item
   The \lcio\ event-format package.  See Sec.~\ref{sec:lcio}.
 \end{itemize}
 Until version v2.2.7 of \whizard, the event-format package \stdhep\ used
 to be available as an external package. As their distribution is frozen
 with the final version v5.06.01, and it used to be notoriously difficult to
 compile and link \stdhep\ into \whizard, it was decided to include \stdhep\
 into \whizard. This is the case from version v2.2.8 of \whizard\ on. Linking
 against an external version of \stdhep\ is precluded from there
 on. Nevertheless, we list some explanations in Sec.~\ref{sec:stdhep}.
 Once these prerequisites are met, you may unpack the package in a
 directory of your choice
 \begin{quote}\small\tt
   some-directory> tar xzf whizard-\thisversion.tgz
 \end{quote}
 and proceed.\footnote{Without GNU \ttt{tar}, this would read
   \ttt{\small gunzip -c whizard-\thisversion.tgz | tar xz -}}
 
 For using external physics models that are directly supported by
 \whizard\ and \oMega, the user can use tools like \sarah\ or
 \FeynRules. There installation and linking to \whizard\ will be
 explained in Chap.~\ref{chap:extmodels}. Besides this, also new models
 can be conveniently included via \UFO\ files, which will be explained
 as well in that chapter.
 
 The directory will then contain a subdirectory \ttt{whizard-\thisversion}
 where the complete source tree is located.  To update later to a new
 version, repeat these steps.  Each new version will unpack in a
 separate directory with the appropriate name.
 
 
 \subsection{SVN Repository Version}
 
 If you want to install the latest development version, you have to
 check it out from the \whizard\ SVN repository.
 
 In addition to the prerequisites listed in the previous section, you
 need:
 \begin{itemize}
 \item
   The \ttt{subversion} package (\ttt{svn}), the tool for dealing with
   SVN repositories.
 \item
   The \ttt{autoconf} package, part of the \ttt{autotools} development
   system.
 \item
   The \ttt{noweb} package, a light-weight tool for literate programming.  This
   package is nowadays often part of Linux distributions\footnote{In
     Ubuntu from version 10.04 on, and in Debian since
     squeeze. For \ttt{Mac OS X}, \ttt{noweb} is available via the
     \ttt{MacPorts} system.}.  You can obtain the source code
   from\footnote{Please, do not use any of the binary builds from this
     webpage. Probably all of them are quite old and broken.}
   \begin{quote}
     \url{http://www.cs.tufts.edu/~nr/noweb/}
   \end{quote}
 \end{itemize}
 To start, go to a directory of your choice and execute
 \begin{interaction}
   your-src-directory> svn checkout https://whizard.hepforge.org/svn/trunk/ .
 \end{interaction}
 The SVN source tree will appear in the current directory.  To update
 later, you just have to execute
 \begin{interaction}
   your-src-directory> svn update
 \end{interaction}
 within that directory.
 
 After checking out the sources, you first have to create
 \ttt{configure.ac} by executing the shell script
 \ttt{build\_master.sh}. Afterwards, run\footnote{At least, version
   2.65 of the \ttt{autoconf} package is required.}
 \begin{interaction}
   your-src-directory> autoreconf
 \end{interaction}
 This will generate a \ttt{configure} script.
 
 
 \subsection{\label{sec:compilers}Fortran Compilers}
 
 \whizard\ is written in modern \fortran.  To be precise, it uses a
 subset of the \fortranOThree\ standard.  At the time of this writing,
 this subset is supported by, at least, the following compilers:
 \begin{itemize}
 \item
   \ttt{gfortran} (GNU, Open Source).  You will need version 4.8.0
   or higher\footnote{Note that \whizard\ versions 2.0.0 until 2.3.1 compiled
   with \ttt{gfortran} 4.7.4, but the object-oriented
   refactoring of the \whizard\ code from 2.4 on made a switch to
   \ttt{gfortran} 4.8.0 or higher necessary.}. We recommend to use at
   least version 4.8.4 or 4.9.4, as especially the the early version of
   4.8.X and 4.9.X experience some severe bugs.
 \item
   \ttt{nagfor} (NAG).  You will need version 6.0 or higher.
 \item
   \ttt{ifort} (Intel). You will need version 17.0.4 or
   higher.
 \end{itemize}
 
 %%%%%
 
 \subsection{LHAPDF}
 \label{sec:lhapdf_install}
 
 For computing scattering processes at hadron colliders such as the
 LHC, \whizard\ has a small set of standard structure-function
 parameterizations built in, cf.\ Sec.~\ref{sec:built-in-pdf}.  For
 many applications, this will be sufficient, and you can skip this
 section.
 
 However, if you need structure-function parameterizations that are not
 in the default set (e.g. PDF error sets), you can use the \lhapdf\
 structure-function library, which is an external package.  It has to
 be linked during \whizard\ installation.  For use with \whizard,
 version 5.3.0 or higher of the library is required\footnote{ Note that
   PDF sets which contain photons as partons are only supported with
   \whizard\ for \lhapdf\ version 5.7.1 or higher}. The \lhapdf\
 package has undergone a major rewriting from \fortran\ version 5
 to \ttt{C++} version 6. While still maintaining the interface for
 the \lhapdf\ version 5 series, from version 2.2.2 of \whizard\ on, the
 new release series of \lhapdf, version 6.0 and higher, is also
 supported.
 
 If \lhapdf\ is not yet installed on your system, you can download it from
 \begin{quote}
   \url{https://lhapdf.hepforge.org}
 \end{quote}
 for the most recent LHAPDF version 6 and newer, or
 \begin{quote}
   \url{https://lhapdf.hepforge.org/lhapdf5}
 \end{quote}
 for version 5 and older, and install it.  The website contains
 comprehensive documentation on the configuring and installation
 procedure.  Make sure that you have downloaded and installed not just
 the package, but also the data sets. Note that \lhapdf\ version 5
 needs both a \fortran\ and a \ttt{C++} compiler.
 
 During \whizard\ configuration, \whizard\ looks for the script
 \ttt{lhapdf} (which is present in \lhapdf\ series 6) first, and then
 for \ttt{lhapdf-config} (which is present since \lhapdf\ version
 4.1.0): if those are in an executable path (or only
 the latter for \lhapdf\ version 5), the environment variables for
 \lhapdf\ are automatically recognized by \whizard, as well as the
 version number. This should look like this in the \ttt{configure}
 output (for \lhapdf\ version 6 or newer),
 
 \begin{footnotesize}
 \begin{verbatim}
    configure: --------------------------------------------------------------
    configure: --- LHAPDF ---
    configure:
    checking for lhapdf... /usr/local/bin/lhapdf
    checking for lhapdf-config... /usr/local/bin/lhapdf-config
    checking the LHAPDF version... 6.1.6
    checking the major version... 6
    checking the LHAPDF pdfsets path... /usr/local/share/LHAPDF
    checking the standard PDF sets...  all standard PDF sets installed
    checking if LHAPDF is functional (may take a while)... yes
    checking LHAPDF... yes
    configure: --------------------------------------------------------------
 \end{verbatim}
 \end{footnotesize}
 while for \lhapdf\ version 5 and older it looks like this:
 
 \begin{footnotesize}
 \begin{verbatim}
    configure: --------------------------------------------------------------
    configure: --- LHAPDF ---
    configure:
    checking for lhapdf... no
    checking for lhapdf-config... /usr/local/bin/lhapdf-config
    checking the LHAPDF version... 5.9.1
    checking the major version... 5
    checking the LHAPDF pdfsets path... /usr/local/share/lhapdf/PDFsets
    checking the standard PDF sets...  all standard PDF sets installed
    checking for getxminm in -lLHAPDF... yes
    checking for has_photon in -lLHAPDF... yes
    configure: --------------------------------------------------------------
 \end{verbatim}
 \end{footnotesize}
 
 If you want to use a different \lhapdf\ (e.g. because the one installed
 on your system by default is an older one), the preferred way to do so
 is to put the \ttt{lhapdf} (and/or \ttt{lhapdf-config}) scripts in an
 executable path that is checked before the system paths,
 e.g. \ttt{<home>/bin}.
 
 For the old series, \lhapdf\ version 5, a possible error could arise
 if \lhapdf\ had been compiled with a different \fortran\ compiler than
 \whizard, and if the run-time library of that \fortran\ compiler had
 not been included in the \whizard\ configure process. The output then
 looks like this:
 
 \begin{footnotesize}
 \begin{verbatim}
    configure: --------------------------------------------------------------
    configure: --- LHAPDF ---
    configure:
    checking for lhapdf... no
    checking for lhapdf-config... /usr/local/bin/lhapdf-config
    checking the LHAPDF version... 5.9.1
    checking the major version... 5
    checking the LHAPDF pdfsets path... /usr/local/share/lhapdf/PDFsets
    checking for standard PDF sets... all standard PDF sets installed
    checking for getxminm in -lLHAPDF... no
    checking for has_photon in -lLHAPDF... no
    configure: --------------------------------------------------------------
 \end{verbatim}
 \end{footnotesize}
 
 So, the \whizard\ configure found the \lhapdf\ distribution, but could
 not link because it could not resolve the symbols inside the
 library. In case of failure, for more details confer the
 \ttt{config.log}.
 
 If \lhapdf\ is installed in a non-default directory where
 \whizard\ would not find it, set the environment variable
 \ttt{LHAPDF\_DIR} to the correct installation path when configuring
 \whizard.
 
 The check for the standard PDF sets are those sets that are used in
 the default \whizard\ self tests in the case \lhapdf\ is enabled and
 correctly linked. If some of them are missing, then this test will
 result in a failure. They are the \ttt{CT10} set for \lhapdf\ version
 6 (for version 5, \ttt{cteq61.LHpdf}, \ttt{cteq6ll.LHpdf},
 \ttt{cteq5l.LHgrid}, and \ttt{GSG961.LHgrid} are demanded). If you
 want to use \lhapdf\ inside \whizard\ please install them such that
 \whizard\ could perform all its sanity checks with them. The last
 check is for the \ttt{has\_photon} flag, which tests whether photon
 PDFs are available in the found \lhapdf\ installation.
 
 %%%%%
 
 \subsection{HOPPET}
 \label{sec:hoppet}
 
 \hoppet\ (not Hobbit) is a tool for the QCD DGLAP evolution of PDFs
 for hadron colliders. It provides possibilities for matching
 algorithms for 4- and 5-flavor schemes, that are important for
 precision simulations of $b$-parton initiated processes at hadron
 colliders. If you are not interested in those features, you can skip
 this section. Note that this feature is not enabled by default (unlike
 e.g. \lhapdf), but has to be explicitly during the configuration
 (see below):
 \begin{interaction}
   your-build-directory> your-src-directory/configure --enable-hoppet
 \end{interaction}
 If you \ttt{configure} messages like the following:
 \begin{footnotesize}
 \begin{verbatim}
 configure: --------------------------------------------------------------
 configure: --- HOPPET ---
 configure:
 checking for hoppet-config... /usr/local/bin/hoppet-config
 checking for hoppetAssign in -lhoppet_v1... yes
 configure: --------------------------------------------------------------
 \end{verbatim}
 \end{footnotesize}
 then you know that \hoppet\ has been found and was correctly
 linked. If that is not the case, you have to specify the location of
 the \hoppet\ library, e.g. by adding
 \begin{interaction}
   HOPPET=<hoppet\_directory>/lib
 \end{interaction}
 to the \ttt{configure} options above. For more details, please confer
 the \hoppet\ manual.
 
 %%%%%
 
 \subsection{HepMC}
 \label{sec:hepmc}
 
 Now, there is also a first attempt to support the new version 3 of
 \hepmc. The configure step can already successfully recognize the two
 different versions, but version 3 is not yet fully functional. So for
 the moment, users should still use version 2. Also, version 3 of
 \hepmc\ still lacks all features of version 2.
 
 \hepmc\ is a \ttt{C++} class library for handling collider scattering
 events.  In particular, it provides a portable format for event files.
 If you want to use this format, you should link \whizard\ with \hepmc,
 otherwise you can skip this section.
 
 If it is not already installed on your system, you may obtain
 \hepmc\ from one of these two webpages:
 \begin{quote}
   \url{http://lcgapp.cern.ch/project/simu/HepMC/}
 \end{quote}
 or
 \begin{quote}
   \url{http://hepmc.web.cern.ch/hepmc/}
 \end{quote}
 If the \hepmc\ library is linked with the installation, \whizard\ is
 able to read and write files in the \hepmc\ format.
 
 Detailed information on the installation and usage can be found on the
 \hepmc\ homepage. We give here only some brief details relevant for
 the usage with \whizard: For the compilation of HepMC one needs a
 \ttt{C++} compiler. Then the procedure is the same as for the
 \whizard\ package, namely configure HepMC:
 \begin{interaction}
   configure --with-momentum=GEV --with-length=MM --prefix=<install dir>
 \end{interaction}
 Note that the particle momentum and decay length flags are mandatory, and
 we highly recommend to set them to the values \ttt{GEV} and \ttt{MM},
 respectively. After configuration, do \ttt{make}, an optional
 \ttt{make check} (which might sometimes fail for non-standard values
 of momentum and length), and finally \ttt{make install}.
 
 A \whizard\ configuration for HepMC looks like this:
 \begin{footnotesize}
   \begin{verbatim}
    configure: --------------------------------------------------------------
    configure: --- HepMC ---
    configure:
    checking the HepMC version... 2.06.09
    checking for GenEvent class in -lHepMC... yes
    configure: --------------------------------------------------------------
   \end{verbatim}
 \end{footnotesize}
 
 If \hepmc\ is installed in a non-default directory where \whizard\
 would not find it, set the environment variable \ttt{HEPMC\_DIR} to
 the correct installation path when configuring \whizard.  Furthermore,
 the environment variable \ttt{CXXFLAGS} allows you to set specific
 \ttt{C/C++} preprocessor flags, e.g. non-standard include paths for
 header files.
 
 %%%%%
 
 \subsection{PYTHIA8}
 \label{sec:pythia8}
 
 \emph{NOTE: This is at the moment not yet supported, but merely a stub
 with the only purpose to be recognized by the build system.}
 
 \pythiaeight\ is a \ttt{C++} class library for handling hadronization,
 showering and underlying event. If you want to use this feature (once it is
 fully supported in \whizard), you should link \whizard\ with \pythiaeight,
 otherwise you can skip this section.
 
 If it is not already installed on your system, you may obtain
 \pythiaeight\ from
 \begin{quote}
   \url{http://home.thep.lu.se/~torbjorn/Pythia.html}
 \end{quote}
 If the \pythiaeight\ library is linked with the installation, \whizard\ will
 be able to use its hadronization and showering, once this is fully supported
 within \whizard.
 
 To link a \pythiaeight\ installation to \whizard, you should specify the flag
 \begin{quote}
 \ttt{--enable-pythia8}
 \end{quote}
 to \ttt{configure}.  If  \pythiaeight\ is installed in a non-default directory
 where \whizard\ would not find it, specify also
 \begin{quote}
 \ttt{--with-pythia8=\emph{<your-pythia8-installation-path>}}
 \end{quote}
 
 A successful \whizard\ configuration should produce a screen output
 similar to this:
 \begin{footnotesize}
 \begin{verbatim}
 configure: --------------------------------------------------------------
 configure: --- SHOWERS PYTHIA6 PYTHIA8 MPI ---
 configure:
 [....]
 checking for pythia8-config... /usr/local/bin/pythia8-config
 checking if PYTHIA8 is functional... yes
 checking PYTHIA8... yes
 configure: WARNING: PYTHIA8 configure is for testing purposes at the moment.
 configure: --------------------------------------------------------------
 \end{verbatim}
 \end{footnotesize}
 
 %%%%%
 
 \subsection{FastJet}
 \label{sec:fastjet}
 
 \emph{NOTE: This is an experimental feature.}
 
 \fastjet\ is a \ttt{C++} class library for handling jet clustering.
 If you want to use this feature, you should link \whizard\ with \fastjet,
 otherwise you can skip this section.
 
 If it is not already installed on your system, you may obtain
 \fastjet\ from
 \begin{quote}
   \url{http://fastjet.fr}
 \end{quote}
 If the \fastjet\ library is linked with the installation, \whizard\ is
 able to call the jet algorithms provided by this program for the purposes of
 applying cuts and analysis.
 
 To link a \fastjet\ installation to \whizard, you should specify the flag
 \begin{quote}
 \ttt{--enable-fastjet}
 \end{quote}
 to \ttt{configure}.  If  \fastjet\ is installed in a non-default directory
 where \whizard\ would not find it, specify also
 \begin{quote}
 \ttt{--with-fastjet=\emph{<your-fastjet-installation-path>}}
 \end{quote}
 
 A successful \whizard\ configuration should produce a screen output
 similar to this:
 \begin{footnotesize}
 \begin{verbatim}
 configure: --------------------------------------------------------------
 configure: --- FASTJET ---
 configure:
 checking for fastjet-config... /usr/local/bin/fastjet-config
 checking if FastJet is functional... yes
 checking FastJet... yes
 configure: --------------------------------------------------------------
 \end{verbatim}
 \end{footnotesize}
 
 %%%%%
 
 \subsection{STDHEP}
 \label{sec:stdhep}
 
 \stdhep\ is a  library for handling collider scattering
 events~\cite{stdhep}.  In particular, it provides a portable format
 for event files. Until version 2.2.7 of \whizard, \stdhep\ that was
 maintained by Fermilab, could be linked as an externally compiled
 library. As the \stdhep\ package is frozen in its final release
 v5.06.1 and no longer maintained, it has from version 2.2.8 been
 included \whizard. This eases many things, as it was notoriously
 difficult to compile and link \stdhep\ in a way compatible with
 \whizard. Not the full package has been included, but only the
 libraries for file I/O (\ttt{mcfio}, the library for the XDR
 conversion), while the various translation tools for \pythia, \herwig,
 etc.  have been abandoned. Note that \stdhep\ has largely been
 replaced in the hadron collider community by the \hepmc\ format, and
 in the lepton collider community by \lcio. \whizard\ might serve as a
 conversion tools for all these formats, but other tools also exist, of
 course.
 
 If the \stdhep\ library is linked with the installation, \whizard\ is
 able to write files in the \stdhep\ format, the  corresponding
 configure output notifies you that \stdhep\ is always included:
 \begin{footnotesize}
 \begin{verbatim}
 configure: --------------------------------------------------------------
 configure: --- STDHEP ---
 configure:
 configure: StdHEP v5.06.01 is included internally
 configure: --------------------------------------------------------------
 \end{verbatim}
 \end{footnotesize}
 
 %%%%%
 
 \subsection{LCIO}
 \label{sec:lcio}
 
 
 \lcio\ is a \ttt{C++} class library for handling collider scattering
 events.  In particular, it provides a portable format for event files.
 If you want to use this format, you should link \whizard\ with \lcio,
 otherwise you can skip this section.
 
 If it is not already installed on your system, you may obtain
 \lcio\ from:
 \begin{quote}
   \url{http://lcio.desy.de}
 \end{quote}
 If the \lcio\ library is linked with the installation, \whizard\ is
 able to read and write files in the \lcio\ format.
 
 Detailed information on the installation and usage can be found on the
 \lcio\ homepage. We give here only some brief details relevant for
 the usage with \whizard: For the compilation of \lcio\ one needs a
 \ttt{C++} compiler. \lcio\ is based on \ttt{cmake}. For the
 corresponding options please confer the \lcio\ manual.
 
 A \whizard\ configuration for \lcio\ looks like this:
 \begin{footnotesize}
   \begin{verbatim}
    configure: --------------------------------------------------------------
    configure: --- LCIO ---
    configure:
    checking the LCIO version... 2.7.1
    checking for LCEventImpl class in -llcio... yes
    configure: --------------------------------------------------------------
   \end{verbatim}
 \end{footnotesize}
 
 If \lcio\ is installed in a non-default directory where \whizard\
 would not find it, set the environment variable \ttt{LCIO} or
 \ttt{LCIO\_DIR} to the correct installation path when configuring
 \whizard.  The first one is the variable exported by the
 \ttt{setup.sh}  script while the second one is analogous to the
 environment variables of other external packages. \ttt{LCIO} takes
 precedence over \ttt{LCIO\_DIR}. Furthermore, the environment variable
 \ttt{CXXFLAGS} allows you to set specific \ttt{C/C++} preprocessor
 flags, e.g. non-standard include paths for header files.
 
 %%%%%
 
 \section{Installation}
 \label{sec:installation}
 
 Once you have unpacked the source (either the tarball or the SVN
 version), you are ready to compile it.  There are several options.
 
 
 \subsection{Central Installation}
 This is the default and recommended way, but it requires adminstrator
 privileges.  Make sure that all
 prerequisites are met (Sec.~\ref{sec:prerequisites}).
 \begin{enumerate}
 \item
   Create a fresh directory for the \whizard\ build.  It is recommended
   to keep this separate from the source directory.
 \item
   Go to that directory and execute
   \begin{interaction}
     your-build-directory> your-src-directory/configure
   \end{interaction}
   This will analyze your system and prepare the compilation of \whizard\
   in the build directory.  Make sure to set the proper options to
   \ttt{configure}, see Sec.~\ref{sec:configure-options} below.
 \item
   Call \ttt{make} to compile and link \whizard:
   \begin{interaction}
     your-build-directory> make
   \end{interaction}
 \item
   If you want to make sure that everything works, run
   \begin{interaction}
     your-build-directory> make check
   \end{interaction}
   This will take some more time.
 \item
   Become superuser and say
   \begin{interaction}
     your-build-directory> make install
   \end{interaction}
 \end{enumerate}
 \whizard\ should now installed in the default locations, and the
 executable should be available in the standard path.  Try to call
 \ttt{whizard --help} in order to check this.
 
 \subsection{Installation in User Space}
 You may lack administrator privileges on your system.  In that case,
 you can still install and run \whizard.  Make sure that all
 prerequisites are met (Sec.~\ref{sec:prerequisites}).
 \begin{enumerate}
 \item
   Create a fresh directory for the \whizard\ build.  It is recommended
   to keep this separate from the source directory.
 \item
   Reserve a directory in user space for the \whizard\ installation.
   It should be empty, or yet non-existent.
 \item
   Go to that directory and execute
   \begin{interaction}
     your-build-directory> your-src-directory/configure
                                --prefix=your-install-directory
   \end{interaction}
   This will analyze your system and prepare the compilation of \whizard\
   in the build directory.  Make sure to set the proper additional options to
   \ttt{configure}, see Sec.~\ref{sec:configure-options} below.
 \item
   Call \ttt{make} to compile and link \whizard:
   \begin{interaction}
     your-build-directory> make
   \end{interaction}
 \item
   If you want to make sure that everything works, run
   \begin{interaction}
     your-build-directory> make check
   \end{interaction}
   This will take some more time.
 \item
   Install:
   \begin{interaction}
     your-build-directory> make install
   \end{interaction}
 \end{enumerate}
 \whizard\ should now be installed in the installation directory of your
 choice.  If the installation is not in your standard search paths, you
 have to account for this by extending the paths appropriately, see
 Sec.~\ref{sec:workspace}.
 
 
 \subsection{Configure Options}
 \label{sec:configure-options}
 
 The configure script accepts environment variables and flags.  They
 can be given as arguments to the \ttt{configure} program in arbitrary
 order.  You may run \ttt{configure --help} for a listing; only the
 last part of this long listing is specific for the \whizard\ system.
 Here is an example:
 \begin{interaction}
   configure  FC=gfortran-4.8  FCFLAGS="-g -O3"  --enable-fc-openmp
 \end{interaction}
 
 The most important options are
 \begin{itemize}
 \item
   \ttt{FC} (variable): The \fortran\ compiler.  This is necessary if
   you need a compiler different from the standard compiler on the
   system, e.g., if the latter is too old.
 \item
   \ttt{FCFLAGS} (variable): The flags to be given to the Fortran
   compiler.  The main use is to control the level of optimization.
 \item
   \ttt{--prefix=\var{directory-name}}: Specify a non-default directory
   for installation.
 \item
   \ttt{--enable-fc-openmp}: Enable parallel executing via OpenMP on a
   multi-processor/multi-core machine.  This works only if OpenMP is
   supported by the compiler (e.g., \ttt{gfortran}).  When running
   \whizard, the number of processors that are actually requested can
   be controlled by the user.  Without this option, \whizard\ will run
   in serial mode on a single core.  See Sec.~\ref{sec:openmp} for
   further details.
 \item
   \ttt{--enable-fc-mpi}: Enable parallel executing via MPI on a single
   machine using several cores or several machines. This works only if a MPI
   library is installed (e.g. \ttt{OpenMPI}) and \ttt{FC=mpifort CC=mpicc CXX=mpic++} is
   set. Without this option, \whizard\ will run in serial mode on a single core.
   The flag can be combined with \ttt{--enable-fc-openmp}. See Sec.~\ref{sec:mpi}
   for further details.
 \item
   \ttt{LHADPF\_DIR} (variable): The location of the optional \lhapdf\
   package, if non-default.
 \item
   \ttt{LOOPTOOLS\_DIR} (variable): The location of the optional \ttt{LOOPTOOLS}
   package, if non-default.
 \item
   \ttt{OPENLOOPS\_DIR} (variable): The location of the optional \openloops\
   package, if non-default.
 \item
   \ttt{GOSAM\_DIR} (variable): The location of the optional \gosam\
   package, if non-default.
 \item
   \ttt{HOPPET\_DIR} (variable): The location of the optional \hoppet\
   package, if non-default.
 \item
   \ttt{HEPMC\_DIR} (variable): The location of the optional \hepmc\ package, if
   non-default.
 \item
   \ttt{LCIO}/\ttt{LCIO\_DIR} (variable): The location of the optional
   \lcio\ package, if non-default.
 \end{itemize}
 
 Other flags that might help to work around possible problems are the
 flags for the $C$ and $C++$ compilers as well as the \ttt{Fortran77}
 compiler, or the linker flags and additional libraries for the linking
 process.
 \begin{itemize}
 \item
   \ttt{CC} (variable): \ttt{C} compiler command
 \item
   \ttt{F77} (variable): \ttt{Fortran77} compiler command
 \item
   \ttt{CXX} (variable): \ttt{C++} compiler command
 \item
   \ttt{CPP} (variable): \ttt{C} preprocessor
 \item
   \ttt{CXXCPP} (variable): \ttt{C++} preprocessor
 \item
   \ttt{CFLAGS} (variable): \ttt{C} compiler flags
 \item
   \ttt{FFLAGS} (variable): \ttt{Fortran77} compiler flags
 \item
   \ttt{CXXFLAGS} (variable): \ttt{C++} compiler flags
 \item
   \ttt{LIBS} (variable): libraries to be passed to the linker as
   \ttt{-l{\em library}}
 \item
   \ttt{LDFLAGS} (variable): non-standard linker flags
 \end{itemize}
 
 For other options (like e.g. \ttt{--with-precision=...} etc.) please
 see the \ttt{configure --help} option.
 
 %%%%%
 
 \subsection{Details on the Configure Process}
 
 The configure process checks for the build and host system type; only
 if this is not detected automatically, the user would have to specify
 this by himself. After that system-dependent files are searched for,
 LaTeX and Acroread for documentation and plots, the \fortran\ compiler
 is checked, and finally the \ocaml\ compiler. The next step is the
 checks for external programs like \lhapdf\ and \ttt{HepMC}.
 Finally, all the Makefiles are being built.
 
 The compilation is done by invoking \ttt{make} and finally
 \ttt{make install}. You could also do a \ttt{make check} in
 order to test whether the compilation has produced sane files on your
 system. This is highly recommended.
 
 Be aware that there be problems for the installation if the install
 path or a user's home directory is part of an AFS file system. Several
 times problems were encountered connected with conflicts with
 permissions inside the OS permission environment variables and the AFS
 permission flags which triggered errors during the \ttt{make install}
 procedure. Also please avoid using \ttt{make -j} options of parallel
 execution of \ttt{Makefile} directives as AFS filesystems might not be
 fast enough to cope with this.
 
 For specific problems that might have been encountered in rare
 circumstances for some FORTRAN compilers confer the webpage
 \url{https://projects.hepforge.org/whizard/compilers.html}.
 
 Note that the \pythia\  bundle for showering and hadronization (and
 some other external legacy code pieces) do still contain good old
 \ttt{Fortran77} code. These parts should better be
 compiled with the very same \ttt{Fortran2003} compiler as the
 \whizard\ core. There is, however, one subtlety:
 when the \ttt{configure} flag \ttt{FC} gets a full system path as
 argument, \ttt{libtool} is not able to recognize this as a valid (GNU)
 \ttt{Fortran77} compiler. It then searches automatically for binaries
 like \ttt{f77}, \ttt{g77} etc. or a standard system compiler. This
 might result in a compilation failure of the \ttt{Fortran77} code. A
 viable solution is to define an executable link and use this (not the
 full path!) as \ttt{FC} flag.
 
 It is possible to compile \whizard\ without the \ocaml\ parts of
 \oMega, namely by using the \ttt{--disable-omega} option of the
 configure. This will result in a built of \whizard\ with the \oMega\
 Fortran library, but without the binaries for the matrix element
 generation. All selftests (cf. \ref{sec:selftests}) requiring \oMega\
 matrix elements are thereby switched off. Note that you can install
 such a built (e.g. on a batch system without \ocaml\ installation), but
 the try to build a distribution (all \ttt{make distxxx} targets) will fail.
 
 
 %%%%%%%%%%%
 
 
 \subsection{\whizard\ self tests/checks}
 \label{sec:selftests}
 
 \whizard\ has a number of self-consistency checks and tests which assure
 that most of its features are running in the intended way. The
 standard procedure to invoke these self tests is to perform a
 \ttt{make check} from the \ttt{build} directory. If \ttt{src}
 and \ttt{build} directories are the same, all relevant files for
 these self-tests reside in the \ttt{tests} subdirectory of the main
 \whizard\ directory. In that case, one could in principle just call the
 scripts individually from the command line. Note, that if \ttt{src}
 and \ttt{build} directory are different as recommended, then the
 input files will have been installed in
 \ttt{prefix/share/whizard/test}, while the corresponding test shell
 scripts remain in the \ttt{srcdir/test} directory. As the main shell
 script \ttt{run\_whizard.sh} has been built in the \ttt{build}
 directory, one now has to copy the files over by and set the correct
 paths by hand, if one wishes to run the test scripts individually.
 \ttt{make check} still correctly performs all \whizard\
 self-consistency tests. The tests itself fall into two categories,
 unit self test that individually test the modular structure of
 \whizard, and tests that are run by \sindarin\ files. In future releases
 of \whizard, these two categories of tests will be better separated
 than in the 2.2.1 release.
 
 There are additional, quite extensiv numerical tests for validation
 and backwards compatibility checks for SM and MSSM processes. As a
 standard, these extended self tests are not invoked. However, they can
 be enabled by executing the corresponding specific \ttt{make check}
 operations in the subdirectories for these extensive tests.
 
 As the new \whizard\ testsuite does very thorough and scrupulous tests
 of the whole \whizard\ structure, it is always possible that some
 tests are failing due to some weird circumstances or because of
 numerical fluctuations. In such a case do not panic, contact the
 developers (\ttt{whizard@desy.de}) and provide them with the logfiles
 of the failing test as well as the setup of your configuration.
 
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \clearpage
 
 \chapter{Working with \whizard}
 \label{chap:start}
 
 \whizard\ can run as a stand-alone program.  You (the user) can steer
 \whizard\ either interactively or by a script file.  We will first
 describe the latter method, since it will be the most common way to
 interact with the \whizard\ system.
 
 \section{Hello World}
 
 The legacy version series 1 of the program relied on a bunch of input
 files that the user had to provide in some obfuscated format.  This
 approach is sufficient for straightforward applications.  However, once
 you get experienced with a program, you start thinking about uses that
 the program's authors did not foresee.  In case of a Monte Carlo
 package, typical abuses are parameter scans, complex patterns of cuts
 and reweighting factors, or data analysis without recourse to external
 packages.  This requires more flexibility.
 
 Instead of transferring control over data input to some generic
 scripting language like PERL or PYTHON (or even C++), which come with
 their own peculiarities and learning curves, we decided to unify data
 input and scripting in a dedicated steering language that is
 particularly adapted to the needs of Monte-Carlo integration,
 simulation, and simple analysis of the results.  Thus we discovered
 what everybody knew anyway: that W(h)izards communicate in \sindarin,
 Scripting INtegration, Data Analysis, Results display and INterfaces.
 
 \sindarin\ is a DSL -- a domain-specific scripting language -- that is
 designed for the single purpose of steering and talking to \whizard.
 Now since \sindarin\ is a programming language, we honor the old
 tradition of starting with the famous Hello World program.  In
 \sindarin\ this reads simply
 \begin{quote}
 \begin{verbatim}
 printf "Hello World!"
 \end{verbatim}
 \end{quote}
 Open your favorite editor, type this text, and save it into a file
 named \verb|hello.sin|.
 
 \begin{figure}
   \centering
 \begin{scriptsize}
 \begin{Verbatim}[frame=single]
     | Writing log to 'whizard.log'
     |=============================================================================|
     |                                                                             |
     |    WW             WW  WW   WW  WW  WWWWWW      WW      WWWWW    WWWW        |
     |     WW    WW     WW   WW   WW  WW     WW      WWWW     WW  WW   WW  WW      |
     |      WW  WW WW  WW    WWWWWWW  WW    WW      WW  WW    WWWWW    WW   WW     |
     |       WWWW   WWWW     WW   WW  WW   WW      WWWWWWWW   WW  WW   WW  WW      |
     |        WW     WW      WW   WW  WW  WWWWWW  WW      WW  WW   WW  WWWW        |
     |                                                                             |
     |                                                                             |
     |                                        W                                    |
     |                                       sW                                    |
     |                                       WW                                    |
     |                                      sWW                                    |
     |                                      WWW                                    |
     |                                     wWWW                                    |
     |                                    wWWWW                                    |
     |                                    WW WW                                    |
     |                                    WW WW                                    |
     |                                   wWW WW                                    |
     |                                  wWW  WW                                    |
     |                                  WW   WW                                    |
     |                                  WW   WW                                    |
     |                                 WW    WW                                    |
     |                                 WW    WW                                    |
     |                                WW     WW                                    |
     |                                WW     WW                                    |
     |           wwwwww              WW      WW                                    |
     |              WWWWWww          WW      WW                                    |
     |                 WWWWWwwwww   WW       WW                                    |
     |                     wWWWwwwwwWW       WW                                    |
     |                 wWWWWWWWWWWwWWW       WW                                    |
     |                wWWWWW       wW        WWWWWWW                               |
     |                  WWWW       wW        WW  wWWWWWWWwww                       |
     |                   WWWW                      wWWWWWWWwwww                    |
     |                     WWWW                      WWWW     WWw                  |
     |                       WWWWww                   WWWW                         |
     |                           WWWwwww              WWWW                         |
     |                               wWWWWwww       wWWWWW                         |
     |                                     WwwwwwwwwWWW                            |
     |                                                                             |
     |                                                                             |
     |                                                                             |
     |  by:   Wolfgang Kilian, Thorsten Ohl, Juergen Reuter                        |
     |        with contributions from Christian Speckner                           |
     |        Contact: <whizard@desy.de>                                           |
     |                                                                             |
     |  if you use WHIZARD please cite:                                            |
     |        W. Kilian, T. Ohl, J. Reuter,  Eur.Phys.J.C71 (2011) 1742            |
     |                                          [arXiv: 0708.4233 [hep-ph]]        |
     |        M. Moretti, T. Ohl, J. Reuter, arXiv: hep-ph/0102195                 |
     |                                                                             |
     |=============================================================================|
     |                               WHIZARD 2.6.4
     |=============================================================================|
     | Reading model file '/usr/local/share/whizard/models/SM.mdl'
     | Preloaded model: SM
     | Process library 'default_lib': initialized
     | Preloaded library: default_lib
     | Reading commands from file 'hello.sin'
     Hello World!
     | WHIZARD run finished.
     |=============================================================================|
 \end{Verbatim}
 \end{scriptsize}
   \caption{Output of the \ttt{"Hello world!"} \sindarin\ script.\label{fig:helloworld}}
 \end{figure}
 
 Now we assume that you -- or your kind system administrator -- has
 installed \whizard\ in your executable path.  Then you should open a
 command shell and execute (we will come to the meaning of the
 \verb|-r| option later.)
 \begin{verbatim}
 /home/user$ whizard -r hello.sin
 \end{verbatim}
 and if everything works well, you get the output (the complete output
 including the \whizard\ banner is shown in Fig.~\ref{fig:helloworld})
 \begin{footnotesize}
 \begin{verbatim}
 | Writing log to 'whizard.log'
 \end{verbatim}
 \centerline{[... here a banner is displayed]}
 \begin{Verbatim}
 |=============================================================================|
 |                               WHIZARD 2.6.4
 |=============================================================================|
 | Reading model file '/usr/local/share/whizard/models/SM.mdl'
 | Preloaded model: SM
 ! Process library 'default_lib': initialized
 ! Preloaded library: default_lib
 | Reading commands from file 'hello.sin'
 Hello World!
 | WHIZARD run finished.
 |=============================================================================|
 \end{Verbatim}
 \end{footnotesize}
 If this has just worked for you, you can be confident that you have a working
 \whizard\ installation, and you have been able to successfully run the
 program.
 
 \section{A Simple Calculation}
 You may object that \whizard\ is not exactly designed for printing out
 plain text.  So let us demonstrate a more useful example.
 
 Looking at the Hello World output, we first observe that the program
 writes a log file named (by default) \verb|whizard.log|.  This file
 receives all screen output, except for the output of external programs
 that are called by \whizard.  You don't have to cache \whizard's screen
 output yourself.
 
 After the welcome banner, \whizard\ tells you that it reads a physics
 \emph{model}, and that it initializes and preloads a \emph{process library}.  The
 process library is initially empty.  It is ready for receiving
 definitions of elementary high-energy physics processes (scattering or
 decay) that you provide.  The processes are set in the context of a
 definite model of high-energy physics.  By default this is the
 Standard Model, dubbed \verb|SM|.
 
 Here is the \sindarin\ code for defining a SM physics process, computing
 its cross section, and generating a simulated event sample in Les Houches
 event format:
 \begin{quote}
 \begin{Verbatim}
 process ee = e1, E1 => e2, E2
 sqrts = 360 GeV
 n_events = 10
 sample_format = lhef
 simulate (ee)
 \end{Verbatim}
 \end{quote}
 As before, you save this text in a file (named, e.g.,
 \verb|ee.sin|) which is run by
 \begin{verbatim}
 /home/user$ whizard -r ee.sin
 \end{verbatim}
 (We will come to the meaning of the \verb|-r| option later.)
 This produces a lot of output which looks similar to this:
 
  \begin{footnotesize}
  \begin{verbatim}
  | Writing log to 'whizard.log'
 [... banner ...]
  |=============================================================================|
  |                               WHIZARD 2.6.4
  |=============================================================================|
  | Reading model file '/usr/local/share/whizard/models/SM.mdl'
  | Preloaded model: SM
  | Process library 'default_lib': initialized
  | Preloaded library: default_lib
  | Reading commands from file 'ee.sin'
  | Process library 'default_lib': recorded process 'ee'
  sqrts =  3.600000000000E+02
  n_events = 10
  \end{verbatim}
 
  \begin{verbatim}
  | Starting simulation for process 'ee'
  | Simulate: process 'ee' needs integration
  | Integrate: current process library needs compilation
  | Process library 'default_lib': compiling ...
  | Process library 'default_lib': writing makefile
  | Process library 'default_lib': removing old files
  rm -f default_lib.la
  rm -f default_lib.lo default_lib_driver.mod opr_ee_i1.mod ee_i1.lo
  rm -f ee_i1.f90
  | Process library 'default_lib': writing driver
  | Process library 'default_lib': creating source code
  rm -f ee_i1.f90
  rm -f opr_ee_i1.mod
  rm -f ee_i1.lo
  /usr/local/bin/omega_SM.opt -o ee_i1.f90 -target:whizard
   -target:parameter_module parameters_SM -target:module opr_ee_i1
   -target:md5sum '70DB728462039A6DC1564328E2F3C3A5' -fusion:progress
   -scatter 'e- e+ -> mu- mu+'
  [1/1] e- e+ -> mu- mu+ ... allowed. [time: 0.00 secs, total: 0.00 secs, remaining: 0.00 secs]
  all processes done. [total time: 0.00 secs]
  SUMMARY: 6 fusions, 2 propagators, 2 diagrams
  | Process library 'default_lib': compiling sources
 [.....]
  \end{verbatim}
 
 
  \begin{verbatim}
  | Process library 'default_lib': loading
  | Process library 'default_lib': ... success.
  | Integrate: compilation done
  | RNG: Initializing TAO random-number generator
  | RNG: Setting seed for random-number generator to 9616
  | Initializing integration for process ee:
  | ------------------------------------------------------------------------
  | Process [scattering]: 'ee'
  |   Library name  = 'default_lib'
  |   Process index = 1
  |   Process components:
  |     1: 'ee_i1':   e-, e+ => mu-, mu+ [omega]
  | ------------------------------------------------------------------------
  | Beam structure: [any particles]
  | Beam data (collision):
  |   e-  (mass = 5.1099700E-04 GeV)
  |   e+  (mass = 5.1099700E-04 GeV)
  |   sqrts = 3.600000000000E+02 GeV
  | Phase space: generating configuration ...
  | Phase space: ... success.
  | Phase space: writing configuration file 'ee_i1.phs'
  | Phase space: 2 channels, 2 dimensions
  | Phase space: found 2 channels, collected in 2 groves.
  | Phase space: Using 2 equivalences between channels.
  | Phase space: wood
  Warning: No cuts have been defined.
  \end{verbatim}
 
 
  \begin{verbatim}
  | Starting integration for process 'ee'
  | Integrate: iterations not specified, using default
  | Integrate: iterations = 3:1000:"gw", 3:10000:""
  | Integrator: 2 chains, 2 channels, 2 dimensions
  | Integrator: Using VAMP channel equivalences
  | Integrator: 1000 initial calls, 20 bins, stratified = T
  | Integrator: VAMP
  |=============================================================================|
  | It      Calls  Integral[fb]  Error[fb]   Err[%]    Acc  Eff[%]   Chi2 N[It] |
  |=============================================================================|
     1        784  8.3282892E+02  1.68E+00    0.20    0.06*  39.99
     2        784  8.3118961E+02  1.23E+00    0.15    0.04*  76.34
     3        784  8.3278951E+02  1.36E+00    0.16    0.05   54.45
  |-----------------------------------------------------------------------------|
     3       2352  8.3211789E+02  8.01E-01    0.10    0.05   54.45    0.50   3
  |-----------------------------------------------------------------------------|
     4       9936  8.3331732E+02  1.22E-01    0.01    0.01*  54.51
     5       9936  8.3341072E+02  1.24E-01    0.01    0.01   54.52
     6       9936  8.3331151E+02  1.23E-01    0.01    0.01*  54.51
  |-----------------------------------------------------------------------------|
     6      29808  8.3334611E+02  7.10E-02    0.01    0.01   54.51    0.20   3
  |=============================================================================|
  \end{verbatim}
 
  \begin{verbatim}
 [.....]
 | Simulate: integration done
 | Simulate: using integration grids from file 'ee_m1.vg'
 | RNG: Initializing TAO random-number generator
 | RNG: Setting seed for random-number generator to 9617
 | Simulation: requested number of events = 10
 |             corr. to luminosity [fb-1] =   1.2000E-02
 | Events: writing to LHEF file 'ee.lhe'
 | Events: writing to raw file 'ee.evx'
 | Events: generating 10 unweighted, unpolarized events ...
 | Events: event normalization mode '1'
 |         ... event sample complete.
 | Events: closing LHEF file 'ee.lhe'
 | Events: closing raw file 'ee.evx'
 | There were no errors and    1 warning(s).
 | WHIZARD run finished.
 |=============================================================================|
  \end{verbatim}
  \end{footnotesize}
 %$
 The final result is the desired event file, \ttt{ee.lhe}.
 
 Let us discuss the output quickly to walk you through the procedures
 of a \whizard\ run: after the logfile message and the banner, the
 reading of the physics model and the initialization of a process
 library, the recorded process with tag \ttt{'ee'} is recorded. Next,
 user-defined parameters like the center-of-mass energy and the number
 of demanded (unweighted) events are displayed. As a next step,
 \whizard\ is starting the simulation of the process with tag
 \ttt{'ee'}. It recognizes that there has not yet been an integration
 over phase space (done by an optional \ttt{integrate} command,
 cf. Sec.~\ref{sec:integrate}), and consequently starts the
 integration. It then acknowledges, that the process code for the
 process \ttt{'ee'} needs to be compiled first (done by an optional
 \ttt{compile} command, cf. Sec.~\ref{sec:compilation}). So, \whizard\
 compiles the process library, writes the makefile for its steering,
 and as a safeguard against garbage removes possibly existing
 files. Then, the source code for the library and its processes are
 generated: for the process code, the default method -- the matrix
 element generator \oMega\ is called (cf. Sec.~\ref{sec:omega_me}); and
 the sources are being compiled.
 
 The next steps are the loading of the process library, and \whizard\
 reports the completion of the integration. For the Monte-Carlo
 integration, a random number generator is initialized. Here, it is the
 default generator, TAO (for more details, cf. Sec.~\ref{sec:tao},
 while the random seed is set to a value initialized by the system
 clock, as no seed has been provided in the \sindarin\ input file.
 
 Now, the integration for the process \ttt{'ee'} is initialized, and
 information about the process (its name, the name of its process
 library, its index inside the library, and the process components out
 of which it consists, cf. Sec.~\ref{sec:processcomp}) are
 displayed. Then, the beam structure is shown, which in that case are
 symmetric partonic electron and positron beams with the center-of-mass
 energy provided by the user (360 GeV). The next step is the generation
 of the phase space, for which the default phase space method
 \ttt{wood} (for more details cf. Sec.~\ref{sec:wood}) is selected. The
 integration is performed, and the result with absolute and relative
 error, unweighting efficiency, accuracy, $\chi^2$ quality is shown.
 
 The final step is the event generation
 (cf. Chap.~\ref{chap:events}). The integration grids are now being
 used, again the random number generator is initialized. Finally, event
 generation of ten unweighted events starts (\whizard\ let us know to
 which integrated luminosity that would correspond), and events are
 written both in an internal (binary) event format as well as in the
 demanded LHE format. This concludes the \whizard\ run.
 
 After a more comprehensive introduction into the \sindarin\ steering
 language in the next chapter, Chap.~\ref{chap:sindarinintro}, we will
 discuss all the details of the different steps of this introductory
 example.
 
 
 \clearpage
 
 \section{WHIZARD in a Computing Environment}
 
 \subsection{Working on a Single Computer}
 \label{sec:workspace}
 
 After installation, \whizard\ is ready for use.  There is a slight
 complication if \whizard\ has been installed in a location that is not
 in your standard search paths.
 
 In that case, to successfully run \whizard, you may either
 \begin{itemize}
 \item
   manually add \ttt{your-install-directory/bin} to your execution PATH\\
   and \ttt{your-install-directory/lib} to your library search path
   (LD\_LIBRARY\_PATH), or
 \item
   whenever you start a project, execute
   \begin{interaction}
     your-workspace> . your-install-directory/bin/whizard-setup.sh
   \end{interaction}
   which will enable the paths in your current environment, or
 \item
   source \ttt{whizard-setup.sh} script in your shell startup file.
 \end{itemize}
 In either case, try to call \ttt{whizard --help} in order to check
 whether this is done correctly.
 
 For a new \whizard\ project, you should set up a new (empty)
 directory.  Depending on the complexity of your task, you may want to
 set up separate directories for each subproblem that you want to
 tackle, or even for each separate run.  The location of the
 directories is arbitrary.
 
 To run, \whizard\ needs only a single input file, a \sindarin\ command
 script with extension \ttt{.sin} (by convention).  Running
 \whizard\ is as simple as
 \begin{interaction}
   your-workspace> whizard your-input.sin
 \end{interaction}
 No other configuration files are needed.  The total number of
 auxiliary and output files generated in a single run may get quite
 large, however, and they may clutter your workspace.  This is the
 reason behind keeping subdirectories on a per-run basis.
 
 Basic usage of \whizard\ is explained in Chapter~\ref{chap:start}, for
 more details, consult the following chapters.  In
 Sec.~\ref{sec:cmdline-options} we give an account of the command-line
 options that \whizard\ accepts.
 
 \subsection{Working Parallel on Several Computers}
 \label{sec:mpi}
 
 For integration (only VAMP2), \whizard\ supports parallel execution via MPI
 by communicating between parallel tasks on a single machine or distributed over
 several machines.
 
 During integration the calculation of channels is distributed along several
 workers where a master worker collects the results and adapts weights and grids.
 In wortwhile cases (e.g. high number of calls in one channel), the calculation
 of a single grid is distributed.
 
 In order to use these advancements, \whizard\ requires an installed MPI-3.1 capable
 library (e.g. OpenMPI) and configuration and compilation with the appropriate flags,
 cf.~Sec.~\ref{sec:installation}.
 
 MPI support is only active when the integration method is set to VAMP2.
 Additionally, to preserve the numerical properties of a single task run, it is
 recommended to use the RNGstream as random number generator.
 \begin{code}
   $integration_method = 'vamp2'
   $rng_method = 'rng_stream'
 \end{code}
 
 \whizard\ has then to be called by mpirun
 \begin{footnotesize}
 \begin{Verbatim}[frame=single]
   your-workspace> mpirun -f hostfile -np 4 --output-filename mpi.log whizard your-input.sin
 \end{Verbatim}
 \end{footnotesize}
 where the number of parallel tasks can be set by \ttt{-np} and a hostfile can be
 given by \ttt{--hostfile}. It is recommended to use \ttt{--output-filename} which
 lets mpirun redirect the standard (error) output to a file, for each worker separatly.
 
 Some caveats exist regarding MPI which are mostly based on output operations.
 Following are known issues,
 \begin{itemize}
 \item runIDs are not supported,
 \item event generation must not be run with MPI.
 \end{itemize}
 The latter can be trivially parallelized by hand.
 
 \subsection{Stopping and Resuming WHIZARD Jobs}
 
 On a Unix-like system, it is possible to prematurely stop running jobs
 by a \ttt{kill(1)} command, or by entering \ttt{Ctrl-C} on the
 terminal.
 
 If the system supports this, \whizard\ traps these signals.  It also
 traps some signals that a batch operating system might issue, e.g.,
 for exceeding a predefined execution time limit.  \whizard\ tries to
 complete the calculation of the current event and gracefully close
 open files.  Then, the program terminates with a message and a nonzero
 return code.  Usually, this should not take more than a fraction of a
 second.
 
 If, for any reason, the program does not respond to an interrupt, it
 is always possible to kill it by \ttt{kill -9}.  A convenient method,
 on a terminal, would be to suspend it first by \ttt{Ctrl-Z} and then
 to kill the suspended process.
 
 The program is usually able to recover after being stopped.  Simply
 run the job again from start, with the same input, all output files
 generated so far left untouched.  The results obtained so far will be
 quickly recovered or gathered from files written in the previous run,
 and the actual time-consuming calculation is resumed near the point
 where it was interrupted.\footnote{This holds for simple workflow.  In
   case of scans and repeated integrations of the same process, there
   may be name clashes on the written files which prevent resuming.  A
   future \whizard\ version will address this problem.}  If the
 interruption happened during an integration step, it is resumed after
 the last complete iteration.  If it was during event generation, the
 previous events are taken from file and event generation is continued.
 
 The same mechanism allows for efficiently redoing a calculation with
 similar, somewhat modified input.  For instance, you might want to add
 a further observable to event analysis, or write the events in a
 different format.  The time for rerunning the program is determined
 just by the time it takes to read the existing integration or event
 files, and the additional calculation is done on the recovered
 information.
 
 By managing various checksums on its input and output files, \whizard\
 detects changes that affect further calculations, so it does a
 real recalculation only where it is actually needed.  This applies to
 all steps that are potentially time-consuming: matrix-element code
 generation, compilation, phase-space setup, integration, and event
 generation.  If desired, you can set command-line options or
 \sindarin\ parameters that explicitly discard previously generated
 information.
 
 
 \subsection{Files and Directories: default and customization}
 
 \whizard\ jobs take a small set of files as input.  In many cases, this is
 just a single \sindarin\ script provided by the user.
 When running, \whizard\ can produce a set of auxiliary and output files:
 \begin{enumerate}
 \item
   \textbf{Job.}
   Files pertaining to the \whizard\ job as a whole.  This is the default log
   file \ttt{whizard.log}.  
 \item
   \textbf{Process compilation.}  Files that originate from generating and
   compiling process code.  If the default \oMega\ generator is used, these
   files include Fortran source code as well as compiled libraries that are
   dynamically linked to the running executable.  The file names are derived
   from either the process-library name or the individual process names, as
   defined in the \sindarin\ input.  The default library name is
   \ttt{default\_lib}.
 \item
   \textbf{Integration.}
   Files that are created by integration, i.e., when calculating the total cross
   section for a scattering process using the Monte-Carlo algorithm.  The file
   names are derived from the process name.
 \item
   \textbf{Simulation.}
   Files that are created during simulation, i.e., generating event samples for
   a process or a set of processes.  By default, the file names are derived
   from the name of the first process.  Event-file formats are distinguished
   by appropriate file name extensions.
 \item
   \textbf{Result Analysis.}
   Files that are created by the internal analysis tools and written by the
   command \ttt{write\_analysis} (or \ttt{compile\_analysis}).  The default
   base name is \ttt{whizard\_analysis}.
 \end{enumerate}
 
 A complex workflow with several processes, parameter sets, or runs, can easily
 lead to in file-name clashes or a messy working directory.  Furthermore,
 running a batch job on a dedicated computing environment often requires
 transferring data from a user directory to the server and back.  
 
 Custom directory and file names can be used to organize things and facilitate
 dealing with the environment, along with the available batch-system tools for
 coordinating file transfer.
 \begin{enumerate}
 \item
   \textbf{Job.}
   \begin{itemize}
   \item
     The \ttt{-L} option on the command line defines a custom base name for
     the log file.
   \item
     The \ttt{-J} option on the command line defines a job ID.  For instance,
     this may be set to the job ID assigned by the batch system.  Within the
     \sindarin\ script, the job ID is available as the string variable
     \ttt{\$job\_id} and can be used for constructing custom job-specific file
     and directory names, as described below.
   \end{itemize}
 \item
   \textbf{Process compilation.}
   \begin{itemize}
   \item
     The user can require the program to put all files created during the
     compilation step including the library to be linked, in a subdirectory of
     the working directory.  To enable this, set the string variable
     \ttt{\$compile\_workspace} within the \sindarin\ script.
   \end{itemize}
 \item
   \textbf{Integration.}
   \begin{itemize}
   \item
     The value of the string variable \ttt{\$run\_id}, if set, is appended to
     the base name of all files created by integration, separated by dots.  If
     the \sindarin\ script scans over parameters, varying the run ID avoids
     repeatedly overwriting files with identical name during the scan.
   \item
     The user can require the program to put the important files created during
     the integration step -- the phase-space configuration file and the
     \vamp\ grid files -- in a subdirectory of the working directory.  To
     enable this, set the string variable \ttt{\$integrate\_workspace} within
     the \sindarin\ script.  (\ttt{\$compile\_workspace} and
     \ttt{\$integrate\_workspace} may be set to the same value.)
   \end{itemize}
   Log files produced during the integration step are put in the working
   directory.
 \item
   \textbf{Simulation.}
   \begin{itemize}
   \item
     The value of the string variable \ttt{\$run\_id}, if set, identifies
     the specific integration run that is used for the event sample.  It is
     also inserted into default event-sample file names.
   \item
     The variable \ttt{\$sample}, if set, defines an arbitrary base name for the
     files related to the event sample.
   \end{itemize}
   Files resulting from simulation are put in the working directory.
 \item
   \textbf{Result Analysis.}
   \begin{itemize}
   \item
     The variable \ttt{\$out\_file}, if set,
     defines an arbitrary base name for the analysis data and
     auxiliary files.
   \end{itemize}
   Files resulting from result analysis are put in the working directory.
 \end{enumerate}
 
 
 \subsection{Batch jobs on a different machine}
 
 It is possible to separate the tasks of process-code compilation, integration,
 and simulation, and execute them on different machines.  To make use of
 this feature, the local and remote machines including all
 installed libraries that are relevant for \whizard, must be
 binary-compatible. 
 \begin{enumerate}
 \item
   Process-code compilation may be done once on a local machine, while the
   time-consuming tasks of integration and event generation for specific
   parameter sets are delegated to a remote machine, e.g., a batch cluster.  To
   enable this, prepare a \sindarin\ script that just produces process code
   (i.e., terminates with a \ttt{compile} command) for the local machine.  You
   may define \ttt{\$compile\_workspace} such that all generated code
   conveniently ends up in a single subdirectory.
 
   To start the batch job, transfer the workspace subdirectory to the remote
   machine 
   and start \whizard\ there.  The \sindarin\ script on the remote machine must
   include the local script unchanged in all parts that are relevant for
   process definition.  The program will recognize the contents of the
   workspace, skip compilation and instead link the process library immediately.
   To proceed further, the script should define the run-specific parameters and
   contain the appropriate commands for integration and simulation.
 \item
   Analogously, you may execute both process-code compilation and integration
   locally, but generate event samples on a remote machine.  To this end,
   prepare a \sindarin\ script that produces process code and computes integrals
   (i.e., terminates with an \ttt{integrate} command) for the local machine.
   You may define \ttt{\$compile\_workspace} and \ttt{\$integrate\_workspace}
   (which may coincide) such that all generated code, phase-space and
   integration grid data conveniently end up in subdirectories.
 
   To start the batch job, transfer the workspace(s) to the remote machine and
   start \whizard\ there.  The \sindarin\ script on the remote machine must
   include the local script unchanged in all parts that are relevant for
   process definition and integration.  The program will recognize the contents
   of the workspace, skip compilation and integration and instead load the
   process library and integration results immediately.  To proceed further,
   the script should define the sample-specific parameters and contain the
   appropriate commands for simulation.
 \end{enumerate}
 
 To simplify transferring whole directories, \whizard\ supports the
 \ttt{--pack} and \ttt{--unpack} options.  You may specify any number of these
 options for a \whizard\ run.  (The feature relies on the GNU version of the
 \ttt{tar} utility.)
 
 For instance,
 \begin{code}
 whizard script1.sin --pack my_ws
 \end{code}
 runs \whizard\ with the \sindarin\ script \ttt{script1.sin} as input, where
 within the script you have defined
 \begin{code}
 $compile_workspace = "my_ws"
 \end{code}
 as the target directory for process-compilation files.  After completion, the
 program will tar and gzip the target directory as \ttt{my\_ws.tgz}.  You
 should copy this file to the remote machine as one of the job's input files.
 
 On the remote machine, you can then run the program with
 \begin{code}
 whizard script2.sin --unpack my_ws.tgz
 \end{code}
 where \ttt{script2.sin} should include \ttt{script1.sin}, and add integration
 or simulation commands.  The contents of \ttt{ws.tgz} will thus be unpacked
 and reused on the remote machine, instead of generating new process code.
 
 
 
 \subsection{Static Linkage}
 
 In its default running mode, \whizard\ compiles process-specific matrix
 element code on the fly and dynamically links the resulting library.  On the
 computing server, this requires availability of the appropriate Fortran
 compiler, as well as the \ocaml\ compiler suite, and the dynamical linking
 feature.
 
 Since this may be unavailable or undesired, there is a possibility to
 distribute \whizard\ as a statically linked executable that contains a
 pre-compiled library of processes.  This removes the need for the Fortran
 compiler, the \ocaml\ system, and extra dynamic linking.  Any external
 libraries that are accessed (the \fortran\ runtime environment, and possibly
 some dynamically linked external libraries and/or the C++ runtime library,
 must still be available on the target system, binary-compatible.  Otherwise,
 there is no need for transferring the complete \whizard\ installation or
 process-code compilation data.
 
 Generating, compiling and linking matrix element code is done in advance on a
 machine that can access the required tools and produces compatible libraries.
 This procedure is accomplished by \sindarin\ commands, explained below in
 Sec.~\ref{sec:static}.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \newpage
 
 \section{Troubleshooting}
 \label{sec:troubleshooting}
 
 In this section, we list known issues or problems and give advice on
 what can be done in case something does not work as intended.
 
 \subsection{Possible (uncommon) build problems}
 \label{sec:buildproblems}
 
 \subsubsection{\ocaml\ versions and \oMega\ builds}
 
 For the matrix element generator \oMega\ of \whizard\, the functional
 programming language \ocaml\ is used. Unfortunately, the versions of
 the \ocaml\ compiler from 3.12.0 on broke backwards
 compatibility. Therefore,  versions of \oMega/\whizard\ up to v2.0.2
 only compile with older versions (3.04 to 3.11 works). This has been
 fixed in all \whizard\ versions from 2.0.3 on.
 
 \subsubsection{Identical Build and Source directories}
 
 There is a problem that only occurred with version 2.0.0 and has been
 corected for all follow-up versions. It can only appear if you
 compile the \whizard\ sources in the source directory. Then an error
 like this may occur:
 \begin{footnotesize}
 \begin{Verbatim}[frame=single]
 ...
 libtool: compile:  gfortran -I../misc -I../vamp -g -O2 -c processes.f90 -fPIC -o
           .libs/processes.o
 libtool: compile:  gfortran -I../misc -I../vamp -g -O2 -c processes.f90 -o
           processes.o >/dev/null 2>&1
 make[2]: *** No rule to make target `limits.lo', needed by `decays.lo'.  Stop.
 ...
 make: *** [all-recursive] Error 1
 \end{Verbatim}
 \end{footnotesize}
 In this case, please unpack a fresh copy of \whizard\ and configure it
 in a separate directory (not necessarily a subdirectory). Then the
 compilation will go through:
 \begin{footnotesize}
 \begin{Verbatim}[frame=single]
 $ zcat whizard-2.0.0.tar.gz | tar xf -
 $ cd whizard-2.0.0
 $ mkdir _build
 $ cd _build
 $ ../configure FC=gfortran
 $ make
 \end{Verbatim}
 \end{footnotesize}
 The developers use this setup to be able to test different
 compilers. Therefore building in the same directory is not as
 thoroughly tested. This behavior has been patched from version 2.0.1
 on. But note that in general it is always adviced to keep
 build and source directory apart from each other.
 
 %%%%%
 
 \subsection{What happens if \whizard\ throws an error?}
 \label{ref:errors}
 
 \subsubsection{Particle name special characters in process
   declarations}
 
 Trying to use a process declaration like
 \begin{code}
 process foo = e-, e+ => mu-, mu+
 \end{code}
 will lead to a \sindarin\ syntax error:
 \begin{Code}
 process foo = e-, e+ => mu-, mu+
                ^^
 | Expected syntax: SEQUENCE    <cmd_process> = process <process_id> '=' <process_p
 | Found token: KEYWORD:    '-'
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR:  Syntax error (at or before the location indicated above)
 ******************************************************************************
 ******************************************************************************
 \end{Code}
 \whizard\ tries to interpret the minus and plus signs as operators
 (\ttt{KEYWORD: '-'}), so you have to quote the particle names:
 \ttt{process foo = "e-", "e+" => "mu-", "mu+"}.
 
 
 \subsubsection{Missing collider energy}
 
 This happens if you forgot to set the collider energy in the
 integration of a scattering process:
 \begin{Code}
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR:  Colliding beams: sqrts is zero (please set sqrts)
 ******************************************************************************
 ******************************************************************************
 \end{Code}
 This will solve your problem:
 \begin{code}
 sqrts = <your_energy>
 \end{code}
 
 \subsubsection{Missing process declaration}
 
 If you try to integrate or simulate a process that has not declared
 before (and is also not available in a library that might be loaded),
 \whizard\ will complain:
 \begin{Code}
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR: Process library doesn't contain process 'f00'
 ******************************************************************************
 ******************************************************************************
 \end{Code}
 Note that this could sometimes be a simple typo, e.g. in that case an
 \ttt{integrate (f00)} instead of \ttt{integrate (foo)}
 
 \subsubsection{Ambiguous initial state without beam declaration}
 
 When the user declares a process with a flavor sum in the initial
 state, e.g.
 \begin{code}
 process qqaa = u:d, U:D => A, A
 sqrts = <your_energy>
 integrate (qqaa)
 \end{code}
 then a fatal error will be issued:
 \begin{Code}
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR: Setting up process 'qqaa':
 ***                 --------------------------------------------
 ***              Inconsistent initial state. This happens if either
 ***              several processes with non-matching initial states
 ***              have been added, or for a single process with an
 ***              initial state flavor sum. In that case, please set beams
 ***              explicitly [singling out a flavor / structure function.]
 ******************************************************************************
 ******************************************************************************
 \end{Code}
 What now? Either a structure function providing a tensor structure in
 flavors has to be provided like
 \begin{code}
 beams = p, pbar => pdf_builtin
 \end{code}
 or, if the partonic process was intended, a specific flavor has to be
 singled out,
 \begin{code}
 beams = u, U
 \end{code}
 which would take only the up-quarks. Note that a sum over process
 components with varying initial states is not possible.
 
 \subsubsection{Invalid or unsupported beam structure}
 
 An error message like
 \begin{Code}
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR: Beam structure: [.......] not supported
 ******************************************************************************
 ******************************************************************************
 \end{Code}
 This happens if you try to use a beam structure with is either not
 supported by \whizard\ (meaning that there is no phase-space
 parameterization for Monte-Carlo integration available in order to
 allow an efficient sampling), or you have chosen a combination of beam
 structure functions that do not make sense physically. Here is an
 example for the latter (lepton collider ISR applied to protons, then
 proton PDFs):
 \begin{code}
 beams = p, p => isr => pdf_builtin
 \end{code}
 
 \subsubsection{Mismatch in beams}
 
 Sometimes you get a rather long error output statement followed by a
 fatal error:
 \begin{Code}
  Evaluator product
  First interaction
  Interaction: 6
  Virtual:
  Particle 1
   [momentum undefined]
 [.......]
  State matrix:  norm =  1.000000000000E+00
  [f(2212)]
    [f(11)]
      [f(92) c(1 )]
        [f(-6) c(-1 )] => ME(1) = ( 0.000000000000E+00, 0.000000000000E+00)
 [.......]
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR: Product of density matrices is empty
 ***                 --------------------------------------------
 ***              This happens when two density matrices are convoluted
 ***              but the processes they belong to (e.g., production
 ***              and decay) do not match. This could happen if the
 ***              beam specification does not match the hard
 ***              process. Or it may indicate a WHIZARD bug.
 ******************************************************************************
 ******************************************************************************
 \end{Code}
 As \whizard\ indicates, this could have happened because the hard
 process setup did not match the specification of the beams as in:
 \begin{code}
 process neutral_current_DIS = e1, u => e1, u
 beams_momentum = 27.5 GeV, 920 GeV
 beams = p, e => pdf_builtin, none
 integrate (neutral_current_DIS)
 \end{code}
 In that case, the order of the beam particles simply was wrong,
 exchange proton and electron (together with the structure functions)
 into \ttt{beams = e, p => none, pdf\_builtin}, and \whizard\ will be
 happy.
 
 \subsubsection{Unstable heavy beam particles}
 
 If you try to use unstable particles as beams that can potentially
 decay into the final state particles, you might encounter the
 following error message:
 \begin{Code}
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR:  Phase space: Initial beam particle can decay
 ******************************************************************************
 ******************************************************************************
 \end{Code}
 This happens basically only for  processes in testing/validation (like
 $t \bar t \to b \bar b$). In principle, it could also happen in a real
 physics setup, e.g. when simulating electron pairs at a muon collider:
 \begin{code}
 process mmee = "mu-", "mu+" => "e-", "e+"
 \end{code}
 However, \whizard\ at the moment does not allow a muon width, and so
 \whizard\ is not able to decay a muon in a scattering process.
 A possibile decay of the beam particle into (part of) the final state
 might lead to instabilities in the phase space setup. Hence, \whizard\
 do not let you perform such an integration right away. When you
 nevertheless encounter such a rare occasion in your setup, there is a
 possibility to convert this fatal error into a simple warning by
 setting the flag:
 \begin{code}
 ?fatal_beam_decay = false
 \end{code}
 
 \subsubsection{Impossible beam polarization}
 
 If you specify a beam polarization that cannot correspond to any
 physically allowed spin density matrix, e.g.,
 \begin{code}
 beams = e1, E1
 beams_pol_density = @(-1), @(1:1:.5, -1, 1:-1)
 \end{code}
 \whizard\ will throw a fatal
 error like this:
 \begin{Code}
  Trace of matrix square =    1.4444444444444444
  Polarization: spin density matrix
    spin type     = 2
    multiplicity  = 2
    massive       = F
    chirality     = 0
    pol.degree    = 1.0000000
    pure state    = F
    @(+1: +1: ( 3.333333333333E-01, 0.000000000000E+00))
    @(-1: -1: ( 6.666666666667E-01, 0.000000000000E+00))
    @(-1: +1: ( 6.666666666667E-01, 0.000000000000E+00))
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR: Spin density matrix: not permissible as density matrix
 ******************************************************************************
 ******************************************************************************
 \end{Code}
 
 \subsubsection{Beams with crossing angle}
 
 Specifying a crossing angle (e.g. at a linear lepton collider) without
 explicitly setting the beam momenta,
 \begin{code}
   sqrts = 1 TeV
   beams = e1, E1
   beams\_theta = 0, 10 degree
 \end{code}
 triggers a fatal:
 \begin{Code}
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR: Beam structure: angle theta/phi specified but momentum/a p undefined
 ******************************************************************************
 ******************************************************************************
 \end{Code}
 In that case the single beam momenta have to be explicitly set:
 \begin{code}
   beams = e1, E1
   beams\_momentum = 500 GeV, 500 GeV
   beams\_theta = 0, 10 degree
 \end{code}
 
 \subsubsection{Phase-space generation failed}
 
 Sometimes an error might be issued that \whizard\ could not generate a
 valid phase-space parameterization:
 \begin{Code}
 | Phase space: ... failed.  Increasing phs_off_shell ...
 | Phase space: ... failed.  Increasing phs_off_shell ...
 | Phase space: ... failed.  Increasing phs_off_shell ...
 | Phase space: ... failed.  Increasing phs_off_shell ...
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR: Phase-space: generation failed
 ******************************************************************************
 ******************************************************************************
 \end{Code}
 You see that \whizard\ tried to increase the number of off-shell lines
 that are taken into account for the phase-space setup. The second most
 important parameter for the phase-space setup, \ttt{phs\_t\_channel},
 however, is not increased automatically. Its default value is $6$, so
 e.g. for the process $e^+ e^- \to 8\gamma$ you will run into the
 problem above. Setting
 \begin{code}
 phs_off_shell = <n>-1
 \end{code}
 where \ttt{<n>} is the number of final-state particles will solve the problem.
 
 \subsubsection{Non-converging process integration}
 
 There could be several reasons for this to happen. The most prominent
 one is that no cuts have been specified for the process (\whizard\ttt{2}
 does not apply default cuts), and there are singular regions in the
 phase space over which the integration stumbles. If cuts have been
 specified, it could be that they are not sufficient. E.g. in $pp \to
 jj$ a distance cut between the two jets prevents singular collinear
 splitting in their generation, but if no $p_T$ cut have been set,
 there is still singular collinear splitting from the beams.
 
 \subsubsection{Why is there no event file?}
 
 If no event file has been generated, \whizard\ stumled over some error
 and should have told you, or, you simply forgot to set a \ttt{simulate}
 command for your process. In case there was a \ttt{simulate} command
 but the process under consideration is not possible (e.g. a typo,
 \ttt{e1, E1 => e2, E3} instead of \ttt{e1, E1 => e3, E3}), then you
 get an error like that:
 \begin{Code}
 ******************************************************************************
 *** ERROR: Simulate: no process has a valid matrix element.
 ******************************************************************************
 \end{Code}
 
 \subsubsection{Why is the event file empty?}
 
 In order to get events, you need to set either a desired number of
 events:
 \begin{code}
 n_events = <integer>
 \end{code}
 or you have to specify a certain integrated luminosity (the default
 unit being inverse femtobarn:
 \begin{code}
 luminosity = <real> / 1 fbarn
 \end{code}
 In case you set both, \whizard\ will take the one that leads to the
 higher number of events.
 
 \subsubsection{Parton showering fails}
 
 For BSM models containing massive stable or long-lived particles
 parton showering with \pythiasix\ fails:
 \begin{Code}
      Advisory warning type 3 given after        0 PYEXEC calls:
      (PYRESD:) Failed to decay particle  1000022 with mass   15.000
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR: Simulation: failed to generate valid event after 10000 tries
 ******************************************************************************
 ******************************************************************************
 \end{Code}
 The solution to that problem is discussed in Sec.~\ref{sec:pythia6}.
 
 \vspace{1cm}
 
 
 %%%%%
 
 \subsection{Debugging, testing, and validation}
 
 
 \subsubsection{Catching/tracking arithmetic exceptions}
 
 Catching arithmetic exceptions is not automatically supported by
 \fortran\ compilers. In general, flags that cause the compiler to keep
 track of arithmetic exceptions are diminishing the maximally possible
 performance, and hence they should not be used in production
 runs. Hence, we refrained from making these flags a default.
 They can be added using the \ttt{FCFLAGS = {\em <flags>}} settings during
 configuration. For the \ttt{NAG} \fortran\ compiler we use the flags
 \ttt{-C=all -nan -gline} for debugging purposes. For the \ttt{gfortran}
 compilers, the flags \ttt{-ffpe-trap=invalid,zero,overflow} are the
 corresponding debugging flags. For tests, debugging or first sanity
 checks on your setup, you might want to make use of these flags in
 order to track possible numerical exceptions in the produced code.
 Some compilers started to include \ttt{IEEE} exception handling
 support (\ttt{Fortran 2008} status), but we do not use these
 implementations in the \whizard\ code (yet).
 
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \chapter{Steering WHIZARD: \sindarin\ Overview}
 \label{chap:sindarinintro}
 
 
 \section{The command language for WHIZARD}
 A conventional physics application program gets its data from a set of input
 files.  Alternatively, it is called as a library, so the user has to write his
 own code to interface it, or it combines these two approaches.  \whizard~1 was
 built in this way: there were some input files which were written by the user,
 and it could be called both stand-alone or as an external library.
 
 \whizard~2 is also a stand-alone program.  It comes with its own full-fledged
 script language, called \sindarin.  All interaction between the user and the
 program is done in \sindarin\ expressions, commands, and scripts.  Two main
 reasons led us to this choice:
 \begin{itemize}
 \item
   In any nontrivial physics study, cuts and (parton- or hadron-level) analysis
   are of central importance.  The task of specifying appropriate kinematics
   and particle selection for a given process is well defined, but it is
   impossible to cover all possiblities in a simple format like the cut files
   of \whizard~1.
 
   The usual way of dealing with this problem is to write analysis driver code
   (often in \ttt{C++}), using external libraries for Lorentz algebra etc.  However,
   the overhead of writing correct \ttt{C++} or \ttt{Fortran} greatly blows up problems
   that could be formulated in a few lines of text.
 \item
   While many problems lead to a repetitive workflow (process definition,
   integration, simulation), there are more involved tasks that involve
   parameter scans, comparisons of different processes, conditional execution,
   or writing output in widely different formats.  This is easily done by a
   steering script, which should be formulated in a complete language.
 \end{itemize}
 The \sindarin\ language is built specifically around event analysis, suitably
 extended to support steering, including data types, loops, conditionals, and
 I/O.
 
 It would have been possible to use an established general-purpose language for
 these tasks.  For instance, \ocaml\ which is a functional language would be a
 suitable candidate, and the matrix-element generator \oMega\ is written in that
 language.  Another candidate would be a popular scripting language such as
 PYTHON.
 
 We started to support interfaces for commonly used languages: prime
 examples for \ttt{C}, \ttt{C++}, and PYTHON are found in the
 \ttt{share/interfaces} subdirectory. However, introducing a
 special-purpose language has the three distinct
 advantages: First, it is compiled and executed by the very \ttt{Fortran} code that
 handles data and thus accesses it without interfaces.  Second, it can be
 designed with a syntax especially suited to the task of event handling and
 Monte-Carlo steering, and third, the user is not forced to learn all those
 features of a generic language that are of no relevance to the application he/she
 is interested in.
 
 
 \section{\sindarin\ scripts}
 
 A \sindarin\ script tells the \whizard\ program what it has to do.  Typically,
 the script is contained in a file which you (the user) create.  The file name
 is arbitrary; by convention, it has the extension `\verb|.sin|'.
 \whizard\ takes the file name as its argument on the command line and
 executes the contained script:
 \begin{verbatim}
 /home/user$ whizard script.sin
 \end{verbatim}
 Alternatively, you can call \whizard\ interactively and execute
 statements line by line; we describe this below in Sec.\ref{sec:whish}.
 
 A \sindarin\ script is a sequence of \emph{statements}, similar to the
 statements in any imperative language such as \ttt{Fortran} or
 \ttt{C}.  Examples of statements are commands like \ttt{integrate},
 variable declarations like \ttt{logical ?flag} or assigments like
 \ttt{mH = 130 GeV}.
 
 The script is free-form, i.e., indentation, extra whitespace and
 newlines are syntactically insignificant.  In contrast to most
 languages, there is no statement separator.  Statements simply follow each
 other, just separated by whitespace.
 \begin{code}
 statement1 statement2
 statement3
                statement4
 \end{code}
 Nevertheless, for clarity we recommend to
 write one statement per line where possible, and to use proper
 indentation for longer statements, nested and bracketed expressions.
 
 A command may consist of a \emph{keyword}, a list of \emph{arguments} in
 parantheses \ttt{(}\ldots\ttt{)}, and an \emph{option} script which
 itself is a sequence of statements.
 \begin{code}
 command
 command_with_args (arg1, arg2)
 command_with_option { option }
 command_with_options (arg) {
   option_statement1
   option_statement2
 }
 \end{code}
 As a rule, parentheses \ttt{()} enclose arguments and expressions, as
 you would expect.  Arguments enclosed in square brackets \ttt{[]} also
 exist.  They have a special meaning, they denote subevents
 (collections of momenta) in event analysis.  Braces \ttt{\{\}} enclose
 blocks of \sindarin\ code.  In particular, the option script
 associated with a command is a block of code that may contain local
 parameter settings, for instance.  Braces always indicate a scoping
 unit, so parameters will be restored their previous values when the
 execution of that command is completed.
 
 The script can contain comments.   Comments are initiated by either a \verb|#|
 or a \verb|!| character and extend to the end of the current line.
 \begin{code}
 statement
 # This is a comment
 statement  ! This is also a comment
 \end{code}
 
 
 %%%%%%%%%%%%%%%
 
 \section{Errors}
 \label{sec:errors}
 
 Before turning to proper \sindarin\ syntax, let us consider error messages.
 \sindarin\ distinguishes syntax errors and runtime errors.
 
 Syntax errors are recognized when the script is read and compiled,
 before any part is executed.  Look at this example:
 \begin{code}
 process foo = u, ubar => d, dbar
 md = 10
 integrade (foo)
 \end{code}
 \whizard\ will fail with the error message
 \begin{interaction}
 sqrts = 1 TeV
 integrade (foo)
           ^^
 | Expected syntax: SEQUENCE    <cmd_num> = <var_name> '=' <expr>
 | Found token: KEYWORD:    '('
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR:  Syntax error (at or before the location indicated above)
 ******************************************************************************
 ******************************************************************************
 WHIZARD run aborted.
 \end{interaction}
 which tells you that you have misspelled the command
 \verb|integrate|, so the compiler tried to interpret it as a variable.
 
 Runtime errors are categorized by their severity.  A warning is simply
 printed:
 \begin{interaction}
 Warning: No cuts have been defined.
 \end{interaction}
 This indicates a condition that is suspicious, but may actually be
 intended by the user.
 
 When an error is encountered, it is printed with more emphasis
 \begin{interaction}
 ******************************************************************************
 *** ERROR: Variable 'md' set without declaration
 ******************************************************************************
 \end{interaction}
 and the program tries to continue.  However, this usually indicates
 that there is something wrong.  (The $d$ quark is defined
 massless, so \verb|md| is not a model parameter.)  \whizard\ counts
 errors and warnings and tells you at the end
 \begin{interaction}
 | There were  1 error(s) and no warnings.
 \end{interaction}
 just in case you missed the message.
 
 Other errors are considered fatal, and execution stops at this point.
 \begin{interaction}
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR:  Colliding beams: sqrts is zero (please set sqrts)
 ******************************************************************************
 ******************************************************************************
 \end{interaction}
 Here, \whizard\ was unable to do anything sensible. But at least (in
 this case) it told the user what to do to resolve the problem.
 
 %%%%%%%%%%%%%%%
 
 \section{Statements}
 \label{sec:statements}
 
 \sindarin\ statements are executed one by one.  For an overview, we
 list the most common statements in the order in which they typically
 appear in a \sindarin\ script, and quote the basic syntax and simple
 examples.  This should give an impression on the \whizard's
 capabilities and on the user interface.  The list is not complete.
 Note that there are no
 mandatory commands (although an empty \sindarin\ script is not really
 useful).  The details and options are explained in later sections.
 
 \subsection{Process Configuration}
 
 \subsubsection{model}
 \begin{syntax}
 model = \var{model-name}
 \end{syntax}
 This assignment sets or resets the current physics model.  The
 Standard Model is already preloaded, so the \ttt{model} assignment
 applies to non-default models.  Obviously, the model must be known to
 \whizard. Example:
 \begin{code}
 model = MSSM
 \end{code}
 See Sec.~\ref{sec:models}.
 
 \subsubsection{alias}
 \begin{syntax}
 alias \var{alias-name} = \var{alias-definition}
 \end{syntax}
 Particles are specified by their names.   For most particles, there
 are various equivalent names.  Names containing special characters
 such as a \verb|+| sign have to be quoted.  The \ttt{alias} assignment
 defines an alias for a list of particles.  This is useful for setting
 up processes with sums over flavors, cut expressions, and more.  The
 alias name is then used like a simple particle name.  Example:
 \begin{syntax}
 alias jet = u:d:s:U:D:S:g
 \end{syntax}
 See Sec.~\ref{sec:alias}.
 
 
 \subsubsection{process}
 \begin{syntax}
 process \var{tag} = \var{incoming} \verb|=>| \var{outgoing}
 \end{syntax}
 Define a process.  You give the process a name \var{tag} by which it is
 identified later, and specify the incoming and outgoing particles,
 and possibly options.  You can define an arbitrary number of processes
 as long as they are distinguished by their names.  Example:
 \begin{code}
 process w_plus_jets = g, g => "W+", jet, jet
 \end{code}
 See Sec.~\ref{sec:processes}.
 
 
 \subsubsection{sqrts}
 \begin{syntax}
 sqrts = \var{energy-value}
 \end{syntax}
 Define the center-of-mass energy for collision processes.  The default
 setup will assume head-on central collisions of two beams.  Example:
 \begin{code}
 sqrts = 500 GeV
 \end{code}
 See Sec.~\ref{sec:beam-setup}.
 
 
 \subsubsection{beams}
 \begin{syntax}
 beams = \var{beam-particles} \\
 beams = \var{beam-particles} => \var{structure-function-setup}
 \end{syntax}
 Declare beam particles and properties.  The current value of \ttt{sqrts} is
 used, unless specified otherwise.  Example:
 \begin{code}
 beams = u:d:s, U:D:S => lhapdf
 \end{code}
 With options, the assignment allows for
 defining beam structure in some detail.  This includes beamstrahlung and ISR
 for lepton colliders, precise structure function definition for hadron
 colliders, asymmetric beams, beam polarization, and more.  See
 Sec.~\ref{sec:beams}.
 
 
 \subsection{Parameters}
 
 \subsubsection{Parameter settings}
 \begin{syntax}
 \var{parameter} = \var{value} \\
 \var{type} \var{user-parameter} \\
 \var{type} \var{user-parameter} = \var{value}
 \end{syntax}
 Specify a value for a parameter.  There are predefined parameters that affect
 the behavior of a command, model-specific parameters (masses, couplings), and
 user-defined parameters.  The latter have to be declared with a type, which
 may be \ttt{int} (integer), \ttt{real}, \ttt{complex}, \ttt{logical},
 \ttt{string}, or \ttt{alias}.  Logical parameter
 names begin with a question mark, string parameter names with a dollar sign.
 Examples:
 \begin{code}
 mb = 4.2 GeV
 ?rebuild_grids = true
 real mass_sum = mZ + mW
 string $message = "This is a string"
 \end{code}
 % $
 The value need not be a literal, it can be an arbitrary expression of the
 correct type.  See Sec.~\ref{sec:variables}.
 
 
 \subsubsection{read\_slha}
 \begin{syntax}
 read\_slha (\var{filename})
 \end{syntax}
 This is useful only for supersymmetric models: read a parameter file
 in the SUSY Les Houches Accord format.  The file defines parameter
 values and, optionally, decay widths, so this command removes the need
 for writing assignments for each of them.
 \begin{code}
 read_slha ("sps1a.slha")
 \end{code}
 See Sec.~\ref{sec:slha}.
 
 
 \subsubsection{show}
 \begin{syntax}
 show (\var{data-objects})
 \end{syntax}
 Print the current value of some data object.  This includes not just
 variables, but also models, libraries, cuts, etc.  This is rather a
 debugging aid, so don't expect the output to be concise in the latter
 cases.  Example:
 \begin{code}
 show (mH, wH)
 \end{code}
 See Sec.~\ref{sec:I/O}.
 
 
 \subsubsection{printf}
 \begin{syntax}
 printf \var{format-string} (\var{data-objects})
 \end{syntax}
 Pretty-print the data objects according to the given format string.
 If there are no data objects, just print the format string.
 This command is borrowed from the \ttt{C} programming language; it is
 actually an interface to the system's \ttt{printf(3)} function.  The
 conversion specifiers are restricted to \ttt{d,i,e,f,g,s},
 corresponding to the output of integer, real, and string variables.
 Example:
 \begin{code}
 printf "The Higgs mass is %f GeV" (mH)
 \end{code}
 See Sec.~\ref{sec:I/O}.
 
 
 \subsection{Integration}
 
 \subsubsection{cuts}
 \begin{syntax}
 cuts = \var{logical-cut-expression}
 \end{syntax}
 The cut expression is a logical macro expression that is evaluated for each
 phase space point during integration and event generation.  You may construct
 expressions out of various observables that are computed for the (partonic)
 particle content of the current event.  If the expression evaluates to
 \verb|true|, the matrix element is calculated and the event is used.  If it
 evaluates to \verb|false|, the matrix element is set zero and the event is
 discarded. Note that for collisions the expression is evaluated in the
 lab frame, while for decays it is evaluated in the rest frame of the
 decaying particle.  In case you want to impose cuts on a factorized
 process, i.e. a combination of a production process and one or more
 decay processes, you have to use the \ttt{selection} keyword
 instead.
 
 Example for the keyword \ttt{cuts}:
 \begin{code}
 cuts = all Pt > 20 GeV [jet]
   and  all mZ - 10 GeV < M < mZ + 10 GeV [lepton, lepton]
   and  no  abs (Eta) < 2 [jet]
 \end{code}
 See Sec.~\ref{sec:cuts}.
 
 
 \subsubsection{integrate}
 \begin{syntax}
 integrate (\var{process-tags})
 \end{syntax}
 Compute the total cross section for a process.  The command takes into account
 the definition of the process, the beam setup, cuts, and parameters as defined
 in the script.  Parameters may also be specified as options to the command.
 
 Integration is necessary for each process for which you want to know total or
 differential cross sections, or event samples.  Apart from computing a value,
 it sets up and adapts phase space and integration grids that are used in event
 generation.   If you just need an event sample, you can omit an explicit
 \ttt{integrate} command; the \ttt{simulate} command will call it
 automatically.  Example:
 \begin{code}
 integrate (w_plus_jets, z_plus_jets)
 \end{code}
 See Sec.~\ref{sec:integrate}.
 
 \subsubsection{?phs\_only/n\_calls\_test}
 \begin{syntax}
 integrate (\var{process-tag}) \{ ?phs\_only = true  n\_calls\_test = 1000 \}
 \end{syntax}
 These are just optional settings for the \ttt{integrate} command
 discussed just a second ago. The \ttt{?phs\_only = true} (note that
 variables starting with a question mark are logicals) option tells
 \whizard\ to prepare a process for integration, but instead of
 performing the integration, just to generate a phase space
 parameterization. \ttt{n\_calls\_test = <num>} evaluates the sampling
 function for random integration channels and random momenta.  \vamp\
 integration grids are neither generated nor used, so the channel
 selection corresponds to the first integration pass, before any grids
 or channel weights are adapted.  The number of sampling points is
 given by \verb|<num>|. The output contains information about the
 timing, number of sampling points that passed the kinematics
 selection, and the number of matrix-element values that were actually
 evaluated. This command is useful mainly for debugging and
 diagnostics.  Example:
 \begin{code}
 integrate (some_large_process) { ?phs_only = true  n_calls_test = 1000 }
 \end{code}
 (Note that there used to be a separate command
 \ttt{matrix\_element\_test} until version 2.1.1 of \whizard\ which has
 been discarded in order to simplify the \sindarin\ syntax.)
 
 \subsection{Events}
 
 \subsubsection{histogram}
 \begin{syntax}
 histogram \var{tag} (\var{lower-bound}, \var{upper-bound}) \\
 histogram \var{tag} (\var{lower-bound}, \var{upper-bound}, \var{step}) \\
 \end{syntax}
 Declare a histogram for event analysis.  The histogram is filled by an
 analysis expression, which is evaluated once for each event during a
 subsequent simulation step.  Example:
 \begin{code}
 histogram pt_distribution (0, 150 GeV, 10 GeV)
 \end{code}
 See Sec.~\ref{sec:histogram}.
 
 
 \subsubsection{plot}
 \begin{syntax}
 plot \var{tag}
 \end{syntax}
 Declare a plot for displaying data points.  The plot may be filled by an
 analysis expression that is evaluated for each event; this would result in a
 scatter plot.  More likely, you will use this feature for displaying data such
 as the energy dependence of a cross section.  Example:
 \begin{code}
 plot total_cross_section
 \end{code}
 See Sec.~\ref{sec:plot}.
 
 
 \subsubsection{selection}
 \begin{syntax}
 selection = \var{selection-expression}
 \end{syntax}
 The selection expression is a logical macro expression that is evaluated once
 for each event. It is applied to the event record,
 after all decays have been executed (if any). It is therefore intended
 e.g. for modelling detector acceptance cuts etc. For unfactorized
 processes the usage of \ttt{cuts} or \ttt{selection} leads to
 the same results. Events for which the selection expression evaluates
 to false are dropped; they are neither analyzed nor written to any
 user-defined output file. However, the dropped events are written to
 \whizard's native event file. For unfactorized processes it is
 therefore preferable to implement all cuts using the \ttt{cuts}
 keyword for the integration, see \ttt{cuts} above.
 Example:
 \begin{code}
 selection = all Pt > 50 GeV [lepton]
 \end{code}
 The syntax is generically the same as for the \ttt{cuts
 expression}, see Sec.~\ref{sec:cuts}. For more information see also
 Sec.~\ref{sec:analysis}.
 
 
 \subsubsection{analysis}
 \begin{syntax}
 analysis = \var{analysis-expression}
 \end{syntax}
 The analysis expression is a logical macro expression that is evaluated once
 for each event that passes the integration and selection cuts in a
 subsequent simulation step.  The
 expression has type logical in analogy with the cut expression; however, its
 main use will be in side effects caused by embedded \ttt{record} expressions.
 The \ttt{record} expression books a value, calculated from observables
 evaluated for the current event, in one of the predefined histograms or plots.
 Example:
 \begin{code}
 analysis = record pt_distribution (eval Pt [photon])
       and  record mval (eval M [lepton, lepton])
 \end{code}
 See Sec.~\ref{sec:analysis}.
 
 
 \subsubsection{unstable}
 \begin{syntax}
 unstable \var{particle} (\var{decay-channels})
 \end{syntax}
 Specify that a particle can decay, if it occurs in the final state of a
 subsequent simulation step.  (In the integration step, all final-state
 particles are considered stable.)  The decay channels are processes which
 should have been declared before by a \ttt{process} command
 (alternatively, there are options that \whizard\ takes care of this
 automatically; cf. Sec.~\ref{sec:decays}).  They may be
 integrated explicitly, otherwise the \ttt{unstable} command will take care of
 the integration before particle decays are generated.  Example:
 \begin{code}
 unstable Z (z_ee, z_jj)
 \end{code}
 Note that the decay is an on-shell approximation.  Alternatively, \whizard\ is
 capable of generating the final state(s) directly, automatically including the
 particle as an internal resonance together with irreducible background.
 Depending on the physical problem and on the complexity of the matrix-element
 calculation, either option may be more appropriate.
 
 See Sec.~\ref{sec:decays}.
 
 
 \subsubsection{n\_events}
 \begin{syntax}
 n\_events = \var{integer}
 \end{syntax}
 Specify the number of events that a subsequent simulation step should produce.
 By default, simulated events are unweighted.  (Unweighting is done by a
 rejection operation on weighted events, so the usual caveats on event
 unweighting by a numerical Monte-Carlo generator do apply.)  Example:
 \begin{code}
 n_events = 20000
 \end{code}
 See Sec.~\ref{sec:simulation}.
 
 
 \subsubsection{simulate}
 \begin{syntax}
 simulate (\var{process-tags})
 \end{syntax}
 Generate an event sample.  The command allows for analyzing the generated
 events by the \ttt{analysis} expression.  Furthermore, events can be written
 to file in various formats.  Optionally, the partonic events can be showered
 and hadronized, partly using included external (\pythia) or truly
 external programs called by \whizard. Example:
 \begin{code}
 simulate (w_plus_jets) { sample_format = lhef }
 \end{code}
 See Sec.~\ref{sec:simulation} and Chapter~\ref{chap:events}.
 
 
 \subsubsection{graph}
 \begin{syntax}
 graph (\var{tag}) = \var{histograms-and-plots}
 \end{syntax}
 Combine existing histograms and plots into a common graph.  Also
 useful for pretty-printing single histograms or plots.  Example:
 \begin{code}
 graph comparison {
   $title = "$p_T$ distribution for two different values of $m_h$"
 } = hist1 & hist2
 \end{code}
 % $
 See Sec.~\ref{sec:graphs}.
 
 
 \subsubsection{write\_analysis}
 \begin{syntax}
 write\_analysis (\var{analysis-objects})
 \end{syntax}
 Writes out data tables for the specified analysis objects (plots,
 graphs, histograms).  If the argument is empty or absent, write all
 analysis objects currently available.  The tables are
 available for feeding external programs.  Example:
 \begin{code}
 write_analysis
 \end{code}
 See Sec.~\ref{sec:analysis}.
 
 
 \subsubsection{compile\_analysis}
 \begin{syntax}
 compile\_analysis (\var{analysis-objects})
 \end{syntax}
 Analogous to \ttt{write\_analysis}, but the generated data tables are
 processed by \LaTeX\ and \gamelan, which produces Postscript and PDF
 versions of the displayed data.  Example:
 \begin{code}
 compile_analysis
 \end{code}
 See Sec.~\ref{sec:analysis}.
 
 
 
 \section{Control Structures}
 
 Like any complete programming language, \sindarin\ provides means for
 branching and looping the program flow.
 
 \subsection{Conditionals}
 
 \subsubsection{if}
 \begin{syntax}
 if \var{logical\_expression} then \var{statements} \\
 elsif \var{logical\_expression} then \var{statements} \\
 else \var{statements} \\
 endif
 \end{syntax}
 Execute statements conditionally, depending on the value of a logical
 expression. There may be none or multiple \ttt{elsif} branches, and
 the \ttt{else} branch is also optional.  Example:
 \begin{code}
 if (sqrts > 2 * mtop) then
   integrate (top_pair_production)
 else
   printf "Top pair production is not possible"
 endif
 \end{code}
 The current \sindarin\ implementation puts some restriction on the
 statements that can appear in a conditional.  For instance, process
 definitions must be done unconditionally.
 
 \subsection{Loops}
 \subsubsection{scan}
 \begin{syntax}
 scan \var{variable} = (\var{value-list}) \{ \var{statements} \}
 \end{syntax}
 Execute the statements repeatedly, once for each value of the scan
 variable.  The statements are executed in a local context, analogous
 to the option statement list for commands.  The value list is a
 comma-separated list of expressions, where each item evaluates to the
 value that is assigned to \ttt{\var{variable}} for this iteration.
 
 The type of the variable is not restricted to numeric, scans can be
 done for various object types.  For instance, here is a scan over strings:
 \begin{code}
 scan string $str = ("%.3g", "%.4g", "%.5g") { printf $str (mW) }
 \end{code}
 % $
 The output:
 \begin{interaction}
 [user variable] $str = "%.3g"
 80.4
 [user variable] $str = "%.4g"
 80.42
 [user variable] $str = "%.5g"
 80.419
 \end{interaction}
 % $
 For a numeric scan variable in particular, there are iterators that
 implement the usual functionality of \ttt{for} loops.  If the scan
 variable is of type integer, an iterator may take one of the forms
 \begin{syntax}
 \var{start-value} \verb|=>| \var{end-value} \\
 \var{start-value} \verb|=>| \var{end-value} \verb|/+| \var{add-step} \\
 \var{start-value} \verb|=>| \var{end-value} \verb|/-| \var{subtract-step} \\
 \var{start-value} \verb|=>| \var{end-value} \verb|/*| \var{multiplicator} \\
 \var{start-value} \verb|=>| \var{end-value} \verb|//| \var{divisor} \\
 \end{syntax}
 The iterator can be put in place of an expression in the
 \ttt{\var{value-list}}.  Here is an example:
 \begin{code}
 scan int i = (1, (3 => 5), (10 => 20 /+ 4))
 \end{code}
 which results in the output
 \begin{interaction}
 [user variable] i =            1
 [user variable] i =            3
 [user variable] i =            4
 [user variable] i =            5
 [user variable] i =           10
 [user variable] i =           14
 [user variable] i =           18
 \end{interaction}
 [Note that the \ttt{\var{statements}} part of the scan construct may
 be empty or absent.]
 
 For real scan variables, there are even more possibilities for iterators:
 \begin{syntax}
 \var{start-value} \verb|=>| \var{end-value} \\
 \var{start-value} \verb|=>| \var{end-value} \verb|/+| \var{add-step} \\
 \var{start-value} \verb|=>| \var{end-value} \verb|/-| \var{subtract-step} \\
 \var{start-value} \verb|=>| \var{end-value} \verb|/*| \var{multiplicator} \\
 \var{start-value} \verb|=>| \var{end-value} \verb|//| \var{divisor} \\
 \var{start-value} \verb|=>| \var{end-value} \verb|/+/| \var{n-points-linear} \\
 \var{start-value} \verb|=>| \var{end-value} \verb|/*/| \var{n-points-logarithmic} \\
 \end{syntax}
 The first variant is equivalent to \ttt{/+ 1}.  The \ttt{/+} and
 \ttt{/-} operators are intended to add or subtract the given step once
 for each iteration.  Since in floating-point arithmetic this would be
 plagued by rounding ambiguities, the actual implementation first
 determines the (integer) number of iterations from the provided step
 value, then recomputes the step so that the iterations are evenly
 spaced with the first and last value included.
 
 The \ttt{/*} and \ttt{//} operators are analogous.  Here, the initial
 value is intended to be multiplied by the step value once for each
 iteration.  After determining the integer number of iterations, the
 actual scan values will be evenly spaced on a logarithmic scale.
 
 Finally, the \ttt{/+/} and \ttt{/*/} operators allow to specify the
 number of iterations (not counting the initial value) directly.  The
 \ttt{\var{start-value}} and \ttt{\var{end-value}} are always included,
 and the intermediate values will be evenly spaced on a linear
 (\ttt{/+/}) or logarithmic (\ttt{/*/}) scale.
 
 Example:
 \begin{code}
 scan real mh = (130 GeV,
            (140 GeV => 160 GeV /+ 5 GeV),
            180 GeV,
            (200 GeV => 1 TeV /*/ 10))
   {  integrate (higgs_decay) }
 \end{code}
 
 
 \subsection{Including Files}
 \subsubsection{include}
 \begin{syntax}
 include (\var{file-name})
 \end{syntax}
 Include a \sindarin\ script from the specified file.  The contents
 must be complete commands; they are compiled and executed as if they
 were part of the current script.  Example:
 \begin{code}
 include ("default_cuts.sin")
 \end{code}
 
 
 
 
 
 \section{Expressions}
 
 \sindarin\ expressions are classified by their types.  The
 type of an expression is verified when the script is compiled, before
 it is executed.  This provides some safety against simple coding
 errors.
 
 Within expressions, grouping is done using ordinary brackets \ttt{()}.
 For subevent expressions, use square brackets \ttt{[]}.
 
 \subsection{Numeric}
 The language supports the classical numeric types
 \begin{itemize}
 \item
    \ttt{int} for integer: machine-default, usually 32 bit;
 \item
    \ttt{real}, usually \emph{double precision} or 64 bit;
 \item
    \ttt{complex}, consisting of real and imaginary part equivalent to a
    \ttt{real} each.
 \end{itemize}
 \sindarin\ supports arithmetic expressions similar to conventional
 languages.  In arithmetic expressions, the three numeric types can be
 mixed as appropriate.  The computation essentially follows the rules
 for mixed arithmetic in \ttt{Fortran}.  The arithmetic operators are
 \verb|+|, \verb|-|, \verb|*|, \verb|/|, \verb|^|. Standard functions
 such as \ttt{sin}, \ttt{sqrt}, etc. are available.  See
 Sec.~\ref{sec:real} to Sec.~\ref{sec:complex}.
 
 Numeric values can be associated with units.  Units evaluate to
 numerical factors, and their use is optional, but they can be useful
 in the physics context for which \whizard\ is designed.  Note that the
 default energy/mass unit is \verb|GeV|, and the default unit for cross
 sections is \verb|fbarn|.
 
 
 \subsection{Logical and String}
 
 The language also has the following standard types:
 \begin{itemize}
 \item
    \ttt{logical} (a.k.a.\ boolean). Logical variable names have a
    \ttt{?} (question mark) as prefix.
 \item
    \ttt{string} (arbitrary length).  String variable names have a \ttt{\$}
    (dollar) sign as prefix.
 \end{itemize}
 There are comparisons, logical operations, string concatenation, and a
 mechanism for formatting objects as strings for output.
 
 
 \subsection{Special}
 
 Furthermore, \sindarin\ deals with a bunch of data types tailored
 specifically for Monte Carlo applications:
 \begin{itemize}
 \item
   \ttt{alias} objects denote a set of particle species.
 \item
   \ttt{subevt} objects denote a collection of particle momenta within an
   event.  They have their uses in cut and analysis expressions.
 \item
   \ttt{process} object are generated by a \ttt{process} statement.
   There are no expressions involving processes, but they are referred
   to by \ttt{integrate} and \ttt{simulate} commands.
 \item
   \ttt{model}: There is always a current object of type and name
   \ttt{model}.  Several models can be used concurrently by
   appropriately defining processes, but this happens behind the scenes.
 \item
   \ttt{beams}: Similarly, the current implementation allows only for a single
   object of this type at a given time, which is assigned by a \ttt{beams =}
   statement and used by \ttt{integrate}.
 \end{itemize}
 
 In the current implementation, \sindarin\ has no container data types
 derived from basic types, such as lists, arrays, or hashes, and there
 are no user-defined data types.  (The \ttt{subevt} type is a container
 for particles in the context of events, but there is no type for an
 individual particle: this is represented as a one-particle
 \ttt{subevt}). There are also containers for inclusive processes which
 are however simply handled as an expansion into several components of
 a master process tag.
 
 
 
 
 
 \section{Variables}
 \label{sec:variables}
 
 \sindarin\ supports global variables, variables local to a scoping unit (the
 option body of a command, the body of a \ttt{scan} loop), and variables local
 to an expression.
 
 Some variables are predefined by the system (\emph{intrinsic
   variables}).  They are further separated into \emph{independent}
 variables that can be reset by the user, and \emph{derived} or locked
 variables that are automatically computed by the program, but not
 directly user-modifiable.  On top of that, the user is free to
 introduce his own variables (\emph{user variables}).
 
 The names of numerical variables consist of alphanumeric characters and
 underscores.  The first character must not be a digit.  Logical
 variable names are furthermore prefixed by a
 \ttt{?} (question mark) sign, while string variable names begin
 with a \ttt{\$} (dollar) sign.
 
 Character case does matter.  In this manual we follow the
 convention that variable names consist of lower-case letters,
 digits, and underscores only, but you may also use upper-case
 letters if you wish.
 
 Physics models contain their own, specific set of numeric variables
 (masses, couplings).  They are attached to the model where they are
 defined, so they appear and disappear with the model that is currently
 loaded.  In particular, if two different models contain a variable
 with the same name, these two variables are nevertheless distinct:
 setting one doesn't affect the other.  This feature might be called,
 in computer-science jargon, a \emph{mixin}.
 
 User variables -- global or local -- are declared by their type when they are
 introduced, and acquire an initial value upon declaration.  Examples:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   int i = 3
   real my_cut_value = 10 GeV
   complex c = 3 - 4 * I
   logical ?top_decay_allowed = mH > 2 * mtop
   string $hello = "Hello world!"
   alias q = d:u:s:c
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 An existing user variable can be assigned a new value without a declaration:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   i = i + 1
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 and it may also be redeclared if the new declaration specifies the same type,
 this is equivalent to assigning a new value.
 
 Variables local to an expression are introduced by the \ttt{let ... in}
 contruct.  Example:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   real a = let int n = 2 in
            x^n + y^n
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 The explicit \ttt{int} declaration is necessary only if the variable \ttt{n}
 has not been declared before.  An intrinsic variable must not be declared:
 \ttt{let mtop = 175.3 GeV in \ldots}
 
 \ttt{let} constructs can be concatenated if several local variables need to
 be assigned: \ttt{let a = 3 in let b = 4 in \textit{expression}}.
 
 Variables of type \ttt{subevt} can only be defined in \ttt{let} constructs.
 
 Exclusively in the context of particle selections (event analysis), there are
 \emph{observables} as special numeric objects.  They are used like numeric
 variables, but they are never declared or assigned.  They get their value
 assigned dynamically, computed from the particle momentum configuration.
 Hence, they may be understood as (intrinsic and predefined) macros.
 By convention, observable names begin with a capital letter.
 
 Further macros are
 \begin{itemize}
 \item
   \ttt{cuts} and \ttt{analysis}.  They are of type logical, and can be
   assigned an expression by the user.  They are evaluated once for
   each event.
 \item
   \ttt{scale}, \ttt{factorization\_scale} and
   \ttt{renormalization\_scale} are real numeric macros which define the
   energy scale(s) of an event.  The latter two override the former.
   If no scale is defined, the partonic energy is used as the process scale.
 \item
   \ttt{weight} is a real numeric macro.  If it is assigned an
   expression, the expression is evaluated for each valid phase-space
   point, and the result multiplies the matrix element.
 \end{itemize}
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \chapter{\sindarin\ in Details}
 \label{chap:sindarin}
 
 \section{Data and expressions}
 
 \subsection{Real-valued objects}
 \label{sec:real}
 
 Real literals have their usual form, mantissa and, optionally, exponent:
 \begin{center}
 \ttt{0.}\quad  \ttt{3.14}\quad \ttt{-.5}\quad
 \ttt{2.345e-3}\quad \ttt{.890E-023}
 \end{center}
 Internally, real values are treated as double precision.  The values are read
 by the Fortran library, so details depend on its implementation.
 
 A special feature of \sindarin\ is that numerics (real and integer) can be
 immediately followed by a physical unit.  The supported units are presently
 hard-coded, they are
 \begin{center}
   \ttt{meV}\quad \ttt{eV}\quad \ttt{keV}\quad
   \ttt{MeV}\quad \ttt{GeV}\quad \ttt{TeV}
 \\
   \ttt{nbarn}\quad \ttt{pbarn}\quad \ttt{fbarn}\quad \ttt{abarn}
 \\
   \ttt{rad}\quad \ttt{mrad}\quad \ttt{degree}
 \\
   \ttt{\%}
 \end{center}
 If a number is followed by a unit, it is automatically normalized to the
 corresponding default unit: \ttt{14.TeV} is transformed into the real number
 \ttt{14000.}  Default units are \ttt{GeV}, \ttt{fbarn}, and \ttt{rad}.  The
 \ttt{\%} sign after a number has the effect that the number is multiplied by
 $0.01$.  Note that no checks for consistency of units are done, so you can add
 \ttt{1 meV + 3 abarn} if you absolutely wish to.  Omitting units is always
 allowed, in that case, the default unit is assumed.
 
 Units are not treated as variables.  In particular, you can't write \ttt{theta
   / degree}, the correct form is \ttt{theta / 1 degree}.
 
 There is a single predefined real constant, namely $\pi$ which is referred to
 by the keyword \ttt{pi}. In addition, there is a single predefined
 complex constant, which is the complex unit $i$, being referred to by
 the keyword \ttt{I}.
 
 The arithmetic operators are
 \begin{center}
   \verb|+| \verb|-| \verb|*| \verb|/| \verb|^|
 \end{center}
 with their obvious meaning and the usual precedence rules.
 
 \sindarin\ supports a bunch of standard numerical functions, mostly equivalent
 to their Fortran counterparts:
 \begin{center}
   \ttt{abs}\quad \ttt{conjg}\quad \ttt{sgn}\quad \ttt{mod}\quad \ttt{modulo}
 \\
   \ttt{sqrt}\quad \ttt{exp}\quad \ttt{log}\quad \ttt{log10}
 \\
   \ttt{sin}\quad \ttt{cos}\quad \ttt{tan}\quad
   \ttt{asin}\quad \ttt{acos}\quad \ttt{atan}
 \\
   \ttt{sinh}\quad \ttt{cosh}\quad \ttt{tanh}
 \end{center}
 (Unlike Fortran, the \ttt{sgn} function takes only one argument and returns
 $1.$, or $-1.$) The function argument is enclosed in brackets: \ttt{sqrt
   (2.)}, \ttt{tan (11.5 degree)}.
 
 There are two functions with two real arguments:
 \begin{center}
   \ttt{max}\quad \ttt{min}
 \end{center}
 Example: \verb|real lighter_mass = min (mZ, mH)|
 
 The following functions of a real convert to integer:
 \begin{center}
   \ttt{int}\quad \ttt{nint}\quad \ttt{floor}\quad \ttt{ceiling} %% \; .
 \end{center}
 and this converts to complex type:
 \begin{center}
   \ttt{complex}
 \end{center}
 
 Real values can be compared by the following operators, the result is a
 logical value:
 \begin{center}
   \verb|==|\quad \verb|<>|
 \\
   \verb|>|\quad \verb|<|\quad \verb|>=|\quad \verb|<=|
 \end{center}
 In \sindarin, it is possible to have more than two operands in a logical
 expressions.  The comparisons are done from left to right.  Hence,
 \begin{center}
   \verb|115 GeV < mH < 180 GeV|
 \end{center}
 is valid \sindarin\ code and evaluates to \ttt{true} if the Higgs mass is in the
 given range.
 
 Tests for equality and inequality with machine-precision real numbers are
 notoriously unreliable and should be avoided altogether.  To deal with this
 problem, \sindarin\ has the possibility to make the comparison operators
 ``fuzzy'' which should be read as ``equal (unequal) up to an absolute
 tolerance'', where the tolerance is given by the real-valued intrinsic
 variable \ttt{tolerance}. This variable is initially zero, but can be
 set to any value (for instance, \ttt{tolerance = 1.e-13} by the user.
 Note that for non-zero tolerance, operators like
 \verb|==| and \verb|<>| or \verb|<| and \verb|>| are not mutually
 exclusive\footnote{In older versions of \whizard, until v2.1.1, there
 used to be separate comparators for the comparisons up to a tolerance,
 namely \ttt{==\~{}} and \ttt{<>\~{}}. These have been discarded from
 v2.2.0 on in order to simplify the syntax.}.
 
 %%%%%%%%%%%%%%%
 
 \subsection{Integer-valued objects}
 \label{sec:integer}
 
 Integer literals are obvious:
 \begin{center}
 \ttt{1}\quad \ttt{-98765}\quad \ttt{0123}
 \end{center}
 Integers are always signed.  Their range is the default-integer range as
 determined by the \fortran\ compiler.
 
 Like real values, integer values can be followed by a physical unit: \ttt{1
   TeV}, \ttt{30 degree}.  This actually transforms the integer into a real.
 
 Standard arithmetics is supported:
 \begin{center}
   \verb|+| \verb|-| \verb|*| \verb|/| \verb|^|
 \end{center}
 It is important to note that there is no fraction datatype, and pure integer
 arithmetics does not convert to real.  Hence \ttt{3/4} evaluates to \ttt{0},
 but \ttt{3 GeV / 4 GeV} evaluates to \ttt{0.75}.
 
 Since all arithmetics is handled by the underlying \fortran\ library, integer
 overflow is not detected.  If in doubt, do real arithmetics.
 
 Integer functions are more restricted than real functions.  We support the
 following:
 \begin{center}
   \ttt{abs}\quad \ttt{sgn}\quad \ttt{mod}\quad \ttt{modulo}
 \\
   \ttt{max}\quad \ttt{min}
 \end{center}
 and the conversion functions
 \begin{center}
   \ttt{real}\quad \ttt{complex}
 \end{center}
 Comparisons of integers among themselves and with reals are possible using the
 same set of comparison operators as for real values.  This includes
 the operators with a finite tolerance.
 
 %%%%%%%%%%%%%%%%
 
 \subsection{Complex-valued objects}
 \label{sec:complex}
 
 Complex variables and values are currently not yet used by the physics
 models implemented in \whizard. There complex input coupling constants
 are always split into their real and imaginary parts (or modulus and
 phase). They are exclusively available for arithmetic calculations.
 
 There is no form for complex literals.  Complex values must be created via an
 arithmetic expression,
 \begin{center}
   \ttt{complex c = 1 + 2 * I}
 \end{center}
 where the imaginary unit \ttt{I} is predefined as a constant.
 
 The standard arithmetic operations are supported (also mixed with real and
 integer).  Support for functions is currently still incomplete, among the
 supported functions there are \ttt{sqrt}, \ttt{log}, \ttt{exp}.
 
 
 
 \subsection{Logical-valued objects}
 
 There are two predefined logical constants, \ttt{true} and \ttt{false}.
 Logicals are \emph{not} equivalent to integers (like in C) or to strings (like
 in PERL), but they make up a type of their own.  Only in \verb|printf| output,
 they are treated as strings, that is, they require the \verb|%s| conversion
 specifier.
 
 The names of logical variables begin with a question mark \ttt{?}.  Here is
 the declaration of a logical user variable:
 \begin{quote}
 \begin{footnotesize}
 \begin{footnotesize}
 \begin{verbatim}
 logical ?higgs_decays_into_tt = mH > 2 * mtop
 \end{verbatim}
 \end{footnotesize}
 \end{footnotesize}
 \end{quote}
 
 Logical expressions use the standard boolean operations
 \begin{center}
   \ttt{or}\quad \ttt{and}\quad \ttt{not}
 \end{center}
 The results of comparisons (see above) are logicals.
 
 There is also a special logical operator with lower priority, concatenation by
 a semicolon:
 \begin{center}
   \ttt{\textit{lexpr1} ; \textit{lexpr2}}
 \end{center}
 This evaluates \textit{lexpr1} and throws its result away, then evaluates
 \textit{lexpr2} and returns that result.  This feature is to used with logical
 expressions that have a side effect, namely the \ttt{record} function within
 analysis expressions.
 
 The primary use for intrinsic logicals are flags that change the behavior of
 commands.  For instance, \ttt{?unweighted = true} and \ttt{?unweighted =
   false} switch the unweighting of simulated event samples on and off.
 
 
 \subsection{String-valued objects and string operations}
 \label{sec:sprintf}
 
 String literals are enclosed in double quotes: \ttt{"This is a string."}
 The empty string is \ttt{""}.  String variables begin with the dollar
 sign: \verb|$|. There is only one string operation, concatenation
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 string $foo = "abc" & "def"
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 
 However, it is possible to transform variables and values to a string using
 the \ttt{sprintf} function.  This function is an interface to the system's \ttt{C}
 function \ttt{sprintf} with some restrictions and modifications.  The allowed
 conversion specifiers are
 \begin{center}
   \verb|%d|\quad \verb|%i| (integer)
 \\
   \verb|%e|\quad \verb|%f|\quad \verb|%g|\quad
   \verb|%E|\quad \verb|%F|\quad \verb|%G| (real)
 \\
   \verb|%s| (string and logical)
 \end{center}
 The conversions can use flag parameter, field width, and precision, but length
 modifiers are not supported since they have no meaning for the application.
 (See also Sec.~\ref{sec:I/O}.)
 
 The \ttt{sprintf} function has the syntax
 \begin{center}
   \ttt{sprintf} \textit{format-string}
   \ttt{(}\textit{arg-list}\ttt{)}
 \end{center}
 This is an expression that evaluates to a string.  The format string contains
 the mentioned conversion specifiers.  The argument list is optional.  The
 arguments are separated by commas.  Allowed arguments are integer, real,
 logical, and string variables, and numeric expressions.  Logical and string
 expressions can also be printed, but they have to be dressed as
 \emph{anonymous variables}.  A logical anonymous variable has the form
 \ttt{?(}\textit{logical\_expr}\ttt{)} (example: \ttt{?(mH > 115 GeV)}).  A
 string anonymous variable has the form \ttt{\$(}\textit{string-expr}\ttt{)}.
 
 Example:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 string $unit = "GeV"
 string $str = sprintf "mW = %f %s" (mW, $unit)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 The related \ttt{printf} command with the same syntax prints the formatted
 string to standard output\footnote{In older versions of \whizard,
   until v2.1.1, there also used to be a \ttt{sprintd} function and a
   \ttt{printd} command for default formats without a format
   string. They have been discarded in order to simplify the syntax
   from version v2.2.0 on.}.
 
 
 \section{Particles and (sub)events}
 
 \subsection{Particle aliases}
 \label{sec:alias}
 
 A particle species is denoted by its name as a string: \verb|"W+"|.
 Alternatively, it can be addressed by an \ttt{alias}.  For instance, the $W^+$
 boson has the alias \ttt{Wp}.  Aliases are used like variables in a context
 where a particle species is expected, and the user can specify his/her own
 aliases.
 
 An alias may either denote a single particle species or a class of particles
 species.  A colon \ttt{:} concatenates particle names and aliases to yield
 multi-species aliases:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 alias quark = u:d:s
 alias wboson = "W+":"W-"
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Such aliases are used for defining processes with summation over flavors, and
 for defining classes of particles for analysis.
 
 Each model files define both names and (single-particle) aliases for all
 particles it contains.  Furthermore, it defines the class aliases
 \verb|colored| and \verb|charged| which are particularly useful for event
 analysis.
 
 
 \subsection{Subevents}
 
 Subevents are sets of particles, extracted from an event.  The sets are
 unordered by default, but may be ordered by appropriate functions.  Obviously,
 subevents are meaningful only in a context where an event is available.  The
 possible context may be the specification of a cut, weight, scale, or analysis
 expression.
 
 To construct a simple subevent, we put a particle alias or an expression of
 type particle alias into square brackets:
 \begin{quote}
 \begin{footnotesize}
   \verb|["W+"]|\quad
   \verb|[u:d:s]|\quad
   \verb|[colored]|
 \end{footnotesize}
 \end{quote}
 These subevents evaluate to the set of all $W^+$ bosons (to be precise, their
 four-momenta), all $u$, $d$, or $s$ quarks, and all colored particles,
 respectively.
 
 A subevent can contain pseudoparticles, i.e., particle combinations.
 That is, the four-momenta of
 distinct particles are combined (added conmponent-wise), and the results
 become subevent elements just like ordinary particles.
 
 The (pseudo)particles in a subevent are non-overlapping.  That is, for
 any of the particles in the original event, there is at most one
 (pseudo)particle in the subevent in which it is contained.
 
 Sometimes, variables (actually, named constants) of type subevent are useful.
 Subevent variables are declared by the \ttt{subevt} keyword, and their
 names carry the prefix \verb|@|.  Subevent variables exist only within the
 scope of a \verb|cuts| (or \verb|scale|, \verb|analysis|, etc.) macro, which
 is evaluated in the presence of an actual event.  In the macro body, they are
 assigned via the \ttt{let} construct:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 cuts =
   let subevt @jets = select if Pt > 10 GeV [colored]
   in
   all Theta > 10 degree [@jets, @jets]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 In this expression, we first define \verb|@jets| to stand for the set of all
 colored partons with $p_T>10\;\mathrm{GeV}$.  This abbreviation is then used
 in a logical expression, which evaluates to true if all relative angles
 between distinct jets are greater than $10$ degree.
 
 We note that the example also introduces pairs of subevents: the square
 bracket with two entries evaluates to the list of all possible pairs which do
 not overlap.  The objects within square brackets can be either subevents or
 alias expressions.  The latter are transformed into subevents before they are
 used.
 
 As a special case, the original event is always available as the predefined
 subevent \verb|@evt|.
 
 \subsection{Subevent functions}
 
 There are several functions that take a subevent (or an alias) as an argument
 and return a new subevent.  Here we describe them:
 
 \subsubsection{collect}
 \begin{quote}
 \begin{footnotesize}
   \ttt{collect [\textit{particles}]} \\
   \ttt{collect if \textit{condition} [\textit{particles}]} \\
   \ttt{collect if \textit{condition} [\textit{particles}, \textit{ref\_particles}]}
 \end{footnotesize}
 \end{quote}
 First version: collect all particle momenta in the argument and combine them
 to a single four-momentum.  The \textit{particles} argument may either be a
 \ttt{subevt} expression or an \ttt{alias} expression.  The result is a
 one-entry \ttt{subevt}.  In the second form, only those particles are collected
 which satisfy the \textit{condition}, a logical expression.  Example:
 \ttt{collect if Pt > 10 GeV [colored]}
 
 The third version is useful if you want to put binary observables (i.e.,
 observables constructed from two different particles) in the condition.  The
 \textit{ref\_particles} provide the second argument for binary observables in
 the \textit{condition}.  A particle is taken into account if the condition is
 true with respect to all reference particles that do not overlap with this
 particle.  Example: \ttt{collect if Theta > 5 degree [photon, charged]}:
 combine all photons that are separated by 5 degrees from all charged
 particles.
 
 
 \subsubsection{cluster}
 \emph{NOTE: This is an experimental feature, available from version
   2.2.1 on.}
 \begin{quote}
 \begin{footnotesize}
   \ttt{cluster [\textit{particles}]} \\
   \ttt{cluster if \textit{condition} [\textit{particles}]} \\
 \end{footnotesize}
 \end{quote}
 First version: collect all particle momenta in the argument and cluster them
 to a set of jets.  The \textit{particles} argument may either be a
 \ttt{subevt} expression or an \ttt{alias} expression.  The result is a
 one-entry \ttt{subevt}.  In the second form, only those particles are clustered
 which satisfy the \textit{condition}, a logical expression.  Example:
 \ttt{cluster if Pt > 10 GeV [colored]}
 
 % The third version is usefule if you want to put binary observables (i.e.,
 % observables constructed from two different particles) in the condition.  The
 % \textit{ref\_particles} provide the second argument for binary observables in
 % the \textit{condition}.  A particle is taken into account if the condition is
 % true with respect to all reference particles that do not overlap with this
 % particle.  Example: \ttt{cluster if Theta > 5 degree [photon, charged]}:
 % combine all photons that are separated by 5 degrees from all charged
 % particles.
 
 This command is available from \whizard\ version 2.2.1 on, and only if
 the \fastjet\ package has been installed and linked with \whizard\
 (cf. Sec.\ref{sec:fastjet}); in a future version of \whizard\ it is
 foreseen to have also an intrinsic clustering package inside \whizard\
 which will be able to support some of the clustering algorithms
 below. To use it in an analysis, you have to set the variable
 \ttt{jet\_algorithm} to one of the predefined jet-algorithm values
 (integer constants):
 \begin{quote}
 \begin{footnotesize}
   \ttt{kt\_algorithm}\\
   \ttt{cambridge\_algorithm}\\
   \ttt{antikt\_algorithm}\\
   \ttt{genkt\_algorithm}\\
   \ttt{cambridge\_for\_passive\_algorithm}\\
   \ttt{genkt\_for\_passive\_algorithm}\\
   \ttt{ee\_kt\_algorithm}\\
   \ttt{ee\_genkt\_algorithm}\\
   \ttt{plugin\_algorithm}
 \end{footnotesize}
 \end{quote}
 and the variable \ttt{jet\_r} to the desired $R$ parameter value, as
 appropriate for the analysis and the jet algorithm.  Example:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   jet_algorithm = antikt_algorithm
   jet_r = 0.7
   cuts = all Pt > 15 GeV [cluster if Pt > 5 GeV [colored]]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 
 
 \subsubsection{combine}
 \begin{quote}
 \begin{footnotesize}
   \ttt{combine [\textit{particles\_1}, \textit{particles\_2}]} \\
   \ttt{combine if \textit{condition}} [\textit{particles\_1}, \textit{particles\_2}]
 \end{footnotesize}
 \end{quote}
 Make a new subevent of composite particles.  The composites are generated by
 combining all particles from subevent \textit{particles\_1} with all particles
 from subevent \textit{particles\_2} in all possible combinations.  Overlapping
 combinations are excluded, however: if a (composite) particle in the first
 argument has a constituent in common with a composite particle in the second
 argument, the combination is dropped.  In particular, this applies if the
 particles are identical.
 
 If a \textit{condition} is provided, the combination is done only when the
 logical expression, applied to the particle pair in question, returns true.
 For instance, here we reconstruct intermediate $W^-$ bosons:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 let @W_candidates = combine if 70 GeV < M < 80 GeV ["mu-", "numubar"]
 in ...
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Note that the combination may fail, so the resulting subevent could be empty.
 
 
 \subsubsection{operator +}
 
 If there is no condition, the $+$ operator provides a convenient
 shorthand for the \verb|combine| command.  In particular, it can be
 used if there are several particles to combine.  Example:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 cuts = any 170 GeV < M < 180 GeV [b + lepton + invisible]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 
 
 \subsubsection{select}
 \begin{quote}
 \begin{footnotesize}
   \ttt{select if \textit{condition} [\textit{particles}]}   \\
   \ttt{select if \textit{condition} [\textit{particles}, \textit{ref\_particles}]}
 \end{footnotesize}
 \end{quote}
 One argument: select all particles in the argument that satisfy the
 \textit{condition} and drop the rest.  Two arguments: the
 \textit{ref\_particles} provide a second argument for binary observables.
 Select particles if the condition is satisfied for all reference particles.
 
 \subsubsection{extract}
 \begin{quote}
 \begin{footnotesize}
   \ttt{extract [\textit{particles}]}   \\
   \ttt{extract index \textit{index-value} [\textit{particles}]}
 \end{footnotesize}
 \end{quote}
 Return a single-particle subevent.  In the first version, it contains the
 first particle in the subevent \textit{particles}.  In the second version, the
 particle with index \textit{index-value} is returned, where
 \textit{index-value} is an integer expression.  If its value is negative, the
 index is counted from the end of the subevent.
 
 The order of particles in an event or subevent is not always well-defined, so
 you may wish to sort the subevent before applying the \textit{extract}
 function to it.
 
 \subsubsection{sort}
 \begin{quote}
 \begin{footnotesize}
    \ttt{sort [\textit{particles}]} \\
    \ttt{sort by \textit{observable} [\textit{particles}]}   \\
    \ttt{sort by \textit{observable} [\textit{particles}, \textit{ref\_particle}]}
 \end{footnotesize}
 \end{quote}
 Sort the subevent according to some criterion.  If no criterion is supplied
 (first version), the subevent is sorted by increasing PDG code (first
 particles, then antiparticles).  In the second version, the
 \textit{observable} is a real expression which is evaluated for each particle
 of the subevent in turn.  The subevent is sorted by increasing value of this
 expression, for instance:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 let @sorted_evt = sort by Pt [@evt]
 in ...
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 In the third version, a reference particle is provided as second argument, so
 the sorting can be done for binary observables.  It doesn't make much sense to
 have several reference particles at once, so the \ttt{sort} function uses
 only the first entry in the subevent \textit{ref-particle}, if it has more
 than one.
 
 
 \subsubsection{join}
 \begin{quote}
 \begin{footnotesize}
   \ttt{join [\textit{particles}, \textit{new\_particles}]} \\
   \ttt{join if \textit{condition} [\textit{particles}, \textit{new\_particles}]}
 \end{footnotesize}
 \end{quote}
 This commands appends the particles in subevent \textit{new\_particles} to the
 subevent \textit{particles}, i.e., it joins the two particle sets.  To be
 precise, a (pseudo)particle from \textit{new\_particles} is only appended if it
 does not overlap with any of the (pseudo)particles
 present in \textit{particles}, so the function will not produce overlapping
 entries.
 
 In the second version, each particle from \textit{new\_particles} is also
 checked with all particles in the first set whether \textit{condition} is
 fulfilled.  If yes, and there is no overlap, it is appended, otherwise
 it is dropped.
 
 
 \subsubsection{operator \&}
 
 Subevents can also be concatenated by the operator \verb|&|.  This effectively
 applies \ttt{join} to all operands in turn.  Example:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 let @visible =
     select if Pt > 10 GeV and E > 5 GeV [photon]
   & select if Pt > 20 GeV and E > 10 GeV [colored]
   & select if Pt > 10 GeV [lepton]
 in ...
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 
 
 \subsection{Calculating observables}
 
 Observables (invariant mass \ttt{M}, energy \ttt{E}, \ldots) are used in
 expressions just like ordinary numeric variables.  By convention, their names
 start with a capital letter.  They are computed using a particle momentum (or
 two particle momenta) which are taken from a subsequent subevent argument.
 
 We can extract the value of an observable for an event and make it available
 for computing the \ttt{scale} value, or for histogramming etc.:
 
 \subsubsection{eval}
 \begin{quote}
 \begin{footnotesize}
   \ttt{eval \textit{expr} [\textit{particles}]} \\
   \ttt{eval \textit{expr} [\textit{particles\_1}, \textit{particles\_2}]}
 \end{footnotesize}
 \end{quote}
 
 The function \ttt{eval} takes an expression involving observables and
 evaluates it for the first momentum (or momentum pair) of the subevent (or
 subevent pair) in square brackets that follows the expression.  For example,
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   eval Pt [colored]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 evaluates to the transverse momentum of the first colored particle,
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   eval M [@jets, @jets]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 evaluates to the invariant mass of the first distinct pair of jets (assuming
 that \verb|@jets| has been defined in a \ttt{let} construct), and
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   eval E - M [combine [e1, N1]]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 evaluates to the difference of energy and mass of the combination of the first
 electron-neutrino pair in the event.
 
 The last example illustrates why observables are treated like variables, even
 though they are functions of particles: the \ttt{eval} construct with the
 particle reference in square brackets after the expression allows to compute
 derived observables -- observables which are functions of new observables --
 without the need for hard-coding them as new functions.
 
 
 \subsection{Cuts and event selection}
 \label{sec:cuts}
 
 Instead of a numeric value, we can use observables to compute a logical value.
 
 \subsubsection{all}
 \begin{quote}
 \begin{footnotesize}
   \ttt{all \textit{logical\_expr} [\textit{particles}]} \\
   \ttt{all \textit{logical\_expr} [\textit{particles\_1}, \textit{particles\_2}]}
 \end{footnotesize}
 \end{quote}
 The \ttt{all} construct expects a logical expression and one or two subevent
 arguments in square brackets.
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   all Pt > 10 GeV [charged]
   all 80 GeV < M < 100 GeV [lepton, antilepton]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 In the second example, \ttt{lepton} and \ttt{antilepton} should be aliases
 defined in a \ttt{let} construct.  (Recall that aliases are promoted to
 subevents if they occur within square brackets.)
 
 This construction defines a cut.  The result value is \ttt{true} if the
 logical expression evaluates to \ttt{true} for all particles in the subevent
 in square brackets.  In the two-argument case it must be \ttt{true} for all
 non-overlapping combinations of particles in the two subevents.  If one of the
 arguments is the empty subevent, the result is also \ttt{true}.
 
 \subsubsection{any}
 \begin{quote}
 \begin{footnotesize}
   \ttt{any \textit{logical\_expr} [\textit{particles}]} \\
   \ttt{any \textit{logical\_expr} [\textit{particles\_1}, \textit{particles\_2}]}
 \end{footnotesize}
 \end{quote}
 The \ttt{any} construct is true if the logical expression is true for at least
 one particle or non-overlapping particle combination:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   any E > 100 GeV [photon]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 This defines a trigger or selection condition.  If a subevent argument is
 empty, it evaluates to \ttt{false}
 
 \subsubsection{no}
 \begin{quote}
 \begin{footnotesize}
   \ttt{no \textit{logical\_expr} [\textit{particles}]} \\
   \ttt{no \textit{logical\_expr} [\textit{particles\_1}, \textit{particles\_2}]}
 \end{footnotesize}
 \end{quote}
 The \ttt{no} construct is true if the logical expression is true for no single
 one particle or non-overlapping particle combination:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   no 5 degree < Theta < 175 degree ["e-":"e+"]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 This defines a veto condition.  If a subevent argument is empty, it
 evaluates to \ttt{true}.  It is equivalent to \ttt{not any\ldots}, but
 included for notational convenience.
 
 
 \subsection{More particle functions}
 
 \subsubsection{count}
 \begin{quote}
 \begin{footnotesize}
   \ttt{count [\textit{particles}]} \\
   \ttt{count [\textit{particles\_1}, \textit{particles\_2}]} \\
   \ttt{count if \textit{logical-expr} [\textit{particles}]} \\
   \ttt{count if \textit{logical-expr} [\textit{particles}, \textit{ref\_particles}]}
 \end{footnotesize}
 \end{quote}
 This counts the number of events in a subevent, the result is of type
 \ttt{int}.  If there is a conditional expression, it counts the number of
 \ttt{particle} in the subevent that pass the test.   If there are two
 arguments, it counts the number of non-overlapping particle pairs (that pass
 the test, if any).
 
 
 \subsubsection{Predefined observables}
 
 The following real-valued observables are available in \sindarin\ for use in
 \ttt{eval}, \ttt{all}, \ttt{any}, \ttt{no}, and \ttt{count} constructs.  The
 argument is always the subevent or alias enclosed in square brackets.
 \begin{itemize}
 \item \ttt{M2}
   \begin{itemize}
   \item One argument: Invariant mass squared of the (composite) particle in the
     argument.
   \item Two arguments: Invariant mass squared of the sum of the two momenta.
   \end{itemize}
 \item \ttt{M}
   \begin{itemize}
   \item Signed square root of \ttt{M2}: positive if $\ttt{M2}>0$, negative if
     $\ttt{M2}<0$.
   \end{itemize}
 \item \ttt{E}
   \begin{itemize}
   \item One argument: Energy of the (composite) particle in the argument.
   \item Two arguments: Sum of the energies of the two momenta.
   \end{itemize}
 \item \ttt{Px}, \ttt{Py}, \ttt{Pz}
   \begin{itemize}
   \item Like \ttt{E}, but returning the spatial momentum components.
   \end{itemize}
 \item \ttt{P}
   \begin{itemize}
   \item Like \ttt{E}, returning the absolute value of the spatial momentum.
   \end{itemize}
 \item \ttt{Pt}, \ttt{Pl}
   \begin{itemize}
   \item Like \ttt{E}, returning the transversal and longitudinal momentum,
     respectively.
   \end{itemize}
 \item \ttt{Theta}
   \begin{itemize}
   \item One argument: Absolute polar angle in the lab frame
   \item Two arguments: Angular distance of two particles in the lab frame.
   \end{itemize}
 \item \ttt{Theta\_star}
   Only with two arguments, gives the relative polar angle of the two momenta
   in the rest system of the momentum sum (i.e. mother particle).
 \item \ttt{Phi}
   \begin{itemize}
   \item One argument: Absolute azimuthal angle in the lab frame
   \item Two arguments: Azimuthal distance of two particles in the lab frame
   \end{itemize}
 \item \ttt{Rap}, \ttt{Eta}
   \begin{itemize}
   \item One argument: rapidity / pseudorapidity
   \item Two arguments: rapidity / pseudorapidity difference
   \end{itemize}
 \item \ttt{Dist}
   \begin{itemize}
   \item Two arguments: Distance on the $\eta$-$\phi$ cylinder, i.e.,
     $\sqrt{\Delta\eta^2 + \Delta\phi^2}$
   \end{itemize}
 \item \ttt{kT}
   \begin{itemize}
   \item Two arguments: $k_T$ jet clustering variable:
     $2 \min (E_{j1}^2, E_{j2}^2) / Q^2 \times (1 -
     \cos\theta_{j1,j2})$. At the moment, $Q^2 = 1$ GeV$^2$.
   \end{itemize}
 \end{itemize}
-There is also an integer-valued observable:
+There are also integer-valued observables:
 \begin{itemize}
 \item \ttt{PDG}
   \begin{itemize}
   \item One argument: PDG code of the particle.  For a composite particle, the
     code is undefined (value 0).
   \end{itemize}
+\item \ttt{Ncol}
+  \begin{itemize}
+  \item One argument: Number of open color lines.  Only count color
+    lines, not anticolor lines.  This is defined only if the global flag
+    \ttt{?colorize\_subevt} is true.
+  \end{itemize}
+\item \ttt{Nacl}
+  \begin{itemize}
+  \item One argument: Number of open anticolor lines.  Only count anticolor
+    lines, not color lines.  This is defined only if the global flag
+    \ttt{?colorize\_subevt} is true.
+  \end{itemize}
 \end{itemize}
 
 
 %%%%%%%%%%%%%%%
 
 \section{Physics Models}
 \label{sec:models}
 
 A physics model is a combination of particles, numerical parameters (masses,
 couplings, widths), and Feynman rules.  Many physics analyses are done in the
 context of the Standard Model (SM).  The SM is also the default model for
 \whizard.  Alternatively, you can choose a subset of the SM (QED or QCD),
 variants of the SM (e.g., with or without nontrivial CKM matrix), or various
 extensions of the SM.  The complete list is displayed in
 Table~\ref{tab:models}.
 
 The model definitions are contained in text files with filename extension
 \ttt{.mdl}, e.g., \ttt{SM.mdl}, which are located in the \ttt{share/models}
 subdirectory of the \whizard\ installation.  These files are easily readable,
 so if you need details of a model implementation, inspect their contents.  The
 model file contains the complete particle and parameter definitions as well as
 their default values.  It also contains a list of vertices.  This is used only
 for phase-space setup; the vertices used for generating amplitudes and the
 corresponding Feynman rules are stored in different files within the
 \oMega\ source tree.
 
 In a \sindarin\ script, a model is a special object of type \ttt{model}.  There
 is always a \emph{current} model.  Initially, this is the SM, so on startup
 \whizard\ reads the \ttt{SM.mdl} model file and assigns its content to the
 current model object.  (You can change the default model by the \ttt{--model}
 option on the command line. Also the preloading of a model can be
 switched off with the \ttt{--no-model} option)  Once the model has
 been loaded, you can define processes for the model, and you have all
 independent model parameters at your disposal.  As noted before, these
 are intrinsic parameters which need not be declared when you assign
 them a value, for instance:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   mW = 80.33 GeV
   wH = 243.1 MeV
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Other parameters are \emph{derived}.  They can be used in expressions like any
 other parameter, they are also intrinsic, but they cannot be modified directly
 at all.  For instance, the electromagnetic coupling \ttt{ee} is a derived
 parameter.  If you change either \ttt{GF} (the Fermi constant), \ttt{mW} (the
 $W$ mass), or \ttt{mZ} (the $Z$ mass), this parameter will reflect the change,
 but setting it directly is an error.  In other words, the SM is defined within
 \whizard\ in the $G_F$-$m_W$-$m_Z$ scheme.  (While this scheme is unusual for
 loop calculations, it is natural for a tree-level event generator where the
 $Z$ and $W$ poles have to be at their experimentally determined
 location\footnote{In future versions of \whizard\ it is foreseen to
   implement other electroweak schemes.}.)
 
 The model also defines the particle names and aliases that you can use for
 defining processes, cuts, or analyses.
 
 If you would like to generate a SUSY process instead, for instance, you can
 assign a different model (cf.\ Table~\ref{tab:models}) to the current model
 object:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   model = MSSM
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 This assignment has the consequence that the list of SM parameters and
 particles is replaced by the corresponding MSSM list (which is much longer).
 The MSSM contains essentially all SM parameters by the same name, but in fact
 they are different parameters.  This is revealed when you say
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   model = SM
   mb = 5.0 GeV
   model = MSSM
   show (mb)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 After the model is reassigned, you will see the MSSM value of $m_b$ which
 still has its default value, not the one you have given.  However, if you
 revert to the SM later,
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   model = SM
   show (mb)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 you will see that your modification of the SM's $m_b$ value has been
 remembered.  If you want both mass values to agree, you have to set them
 separately in the context of their respective model.  Although this might seem
 cumbersome at first, it is nevertheless a sensible procedure since the
 parameters defined by the user might anyhow not be defined or available for
 all chosen models.
 
 When using two different models which need an SLHA input file,
 these {\em have} to be provided for both models.
 
 Within a given scope, there is only one current model.  The current model can
 be reset permanently as above.  It can also be temporarily be reset in a local
 scope, i.e., the option body of a command or the body of a \ttt{scan} loop.
 It is thus possible to use several models within the same script.  For
 instance, you may define a SUSY signal process and a pure-SM background
 process. Each process depends only on the respective model's parameter set,
 and a change to a parameter in one of the models affects only the
 corresponding process.
 
 
 \section{Processes}
 \label{sec:processes}
 
 The purpose of \whizard\ is the integration and simulation of high-energy
 physics processes: scatterings and decays.  Hence, \ttt{process} objects play
 the central role in \sindarin\ scripts.
 
 A \sindarin\ script may contain an arbitrary number of process definitions.  The
 initial states need not agree, and the processes may belong to different
 physics models.
 
 
 \subsection{Process definition}
 \label{sec:procdef}
 
 A process object is defined in a straightforward notation.  The definition
 syntax is straightforward:
 \begin{quote}
 \begin{footnotesize}
   \ttt{process \textit{process-id} = \textit{incoming-particles}} \verb|=>|
   \ttt{\textit{outgoing-particles}}
 \end{footnotesize}
 \end{quote}
 Here are typical examples:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   process w_pair_production = e1, E1 => "W+", "W-"
   process zdecay = Z => u, ubar
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Throughout the program, the process will be identified by its
 \textit{process-id}, so this is the name of the process object.  This
 identifier is arbitrary, chosen by the user.  It follows the rules for
 variable names, so it consists of alphanumeric characters and underscores,
 where the first character is not numeric.  As a special rule, it must not
 contain upper-case characters.  The reason is that this name is used for
 identifying the process not just within the script, but also within the
 \fortran\ code that the matrix-element generator produces for this process.
 
 After the equals sign, there follow the lists of incoming and outgoing
 particles.  The number of incoming particles is either one or two: scattering
 processes and decay processes.  The number of outgoing particles should be two
 or larger (as $2\to 1$ processes are proportional to a $\delta$
 function they can only be sensibly integrated when using a structure
 function like a hadron collider PDF or a beamstrahlung spectrum.).
 There is no hard upper limit; the complexity of processes that
 \whizard\ can handle depends only on the practical computing
 limitations (CPU time and memory).  Roughly speaking, one can assume
 that processes up to $2\to 6$ particles are safe, $2\to 8$ processes
 are feasible given sufficient time for reaching a stable integration,
 while more complicated processes are largely unexplored.
 
 We emphasize that in the default setup, the matrix element of a physics
 process is computed exactly in leading-order perturbation theory, i.e., at
 tree level.  There is no restriction of intermediate states, the result always
 contains the complete set of Feynman graphs that connect the initial with the
 final state.  If the result would actually be expanded in Feynman graphs
 (which is not done by the \oMega\ matrix element generator that
 \whizard\ uses), the number of graphs can easily reach several thousands,
 depending on the complexity of the process and on the physics model.
 
 More details about the different methods for quantum field-theoretical
 matrix elements can be found in Chap.~\ref{chap:hardint}. In the
 following, we will discuss particle names, options for processes like
 restrictions on intermediate states, parallelization, flavor sums and
 process components for inclusive event samples (process containers).
 
 
 \subsection{Particle names}
 
 The particle names are taken from the particle definition in the current model
 file.  Looking at the SM, for instance, the electron entry in
 \ttt{share/models/SM.mdl} reads
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 particle E_LEPTON 11
   spin 1/2  charge  -1   isospin -1/2
   name "e-" e1 electron e
   anti "e+" E1 positron
   tex_name "e^-"
   tex_anti "e^+"
   mass me
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 This tells that you can identify an electron either as \verb|"e-"|, \verb|e1|,
 \verb|electron|, or simply \verb|e|.  The first version is used for output,
 but needs to be quoted, because otherwise \sindarin\ would interpret the minus
 sign as an operator.  (Technically, unquoted particle identifiers are aliases,
 while the quoted versions -- you can say either \verb|e1| or \verb|"e1"| --
 are names.  On input, this makes no difference.)  The alternative version
 \verb|e1| follows a convention, inherited from
 \comphep~\cite{Boos:2004kh}, that particles are indicated by lower
 case, antiparticles by upper case, and for leptons, the generation
 index is appended: \verb|e2| is the muon, \verb|e3| the tau.  These
 alternative names need not be quoted because they contain no special
 characters.
 
 In Table~\ref{tab:SM-particles}, we list the recommended names as well as
 mass and width parameters for all SM particles.  For other models, you may
 look up the names in the corresponding model file.
 
 \begin{table}[p]
   \begin{center}
     \begin{tabular}{|l|l|l|l|cc|}
       \hline
       & Particle & Output name & Alternative names & Mass & Width\\
       \hline\hline
       Leptons
       &$e^-$ & \verb|e-| & \ttt{e1}\quad\ttt{electron} & \ttt{me} & \\
       &$e^+$ & \verb|e+| & \ttt{E1}\quad\ttt{positron} & \ttt{me} & \\
       \hline
       &$\mu^-$ & \verb|mu-| & \ttt{e2}\quad\ttt{muon} & \ttt{mmu} & \\
       &$\mu^+$ & \verb|mu+| & \ttt{E2} & \ttt{mmu} & \\
       \hline
       &$\tau^-$ & \verb|tau-| & \ttt{e3}\quad\ttt{tauon} & \ttt{mtau} & \\
       &$\tau^+$ & \verb|tau+| & \ttt{E3} & \ttt{mtau} & \\
       \hline\hline
       Neutrinos
       &$\nu_e$ & \verb|nue| & \ttt{n1} & & \\
       &$\bar\nu_e$ & \verb|nuebar| & \ttt{N1} & & \\
       \hline
       &$\nu_\mu$ & \verb|numu| & \ttt{n2} & & \\
       &$\bar\nu_\mu$ & \verb|numubar| & \ttt{N2} & & \\
       \hline
       &$\nu_\tau$ & \verb|nutau| & \ttt{n3} & & \\
       &$\bar\nu_\tau$ & \verb|nutaubar| & \ttt{N3} & & \\
       \hline\hline
       Quarks
       &$d$ & \verb|d| & \ttt{down} & & \\
       &$\bar d$ & \verb|dbar| & \ttt{D} & & \\
       \hline
       &$u$ & \verb|u| & \ttt{up} & & \\
       &$\bar u$ & \verb|ubar| & \ttt{U} & & \\
       \hline
       &$s$ & \verb|s| & \ttt{strange} & \ttt{ms} & \\
       &$\bar s$ & \verb|sbar| & \ttt{S} & \ttt{ms}  & \\
       \hline
       &$c$ & \verb|c| & \ttt{charm} & \ttt{mc}  & \\
       &$\bar c$ & \verb|cbar| & \ttt{C} & \ttt{mc} & \\
       \hline
       &$b$ & \verb|b| & \ttt{bottom} & \ttt{mb} & \\
       &$\bar b$ & \verb|bbar| & \ttt{B} &  \ttt{mb} & \\
       \hline
       &$t$ & \verb|t| & \ttt{top} &  \ttt{mtop} & \ttt{wtop} \\
       &$\bar t$ & \verb|tbar| & \ttt{T} &  \ttt{mtop} & \ttt{wtop} \\
       \hline\hline
       Vector bosons
       &$g$ & \verb|gl| & \ttt{g}\quad\ttt{G}\quad\ttt{gluon} & & \\
       \hline
       &$\gamma$ & \verb|A| & \ttt{gamma}\quad\ttt{photon} & & \\
       \hline
       &$Z$ & \verb|Z| & & \ttt{mZ} & \ttt{wZ} \\
       \hline
       &$W^+$ & \verb|W+| & \ttt{Wp} & \ttt{mW} & \ttt{wW} \\
       &$W^-$ & \verb|W-| & \ttt{Wm} & \ttt{mW} & \ttt{wW} \\
       \hline\hline
       Scalar bosons
       &$H$ & \verb|H| & \ttt{h}\quad \ttt{Higgs} & \ttt{mH} & \ttt{wH} \\
       \hline
     \end{tabular}
   \end{center}
   \caption{\label{tab:SM-particles} Names that can be used for SM particles.
     Also shown are the intrinsic variables that can be used to set mass and
     width, if applicable.}
 \end{table}
 
 Where no mass or width parameters are listed in the table, the particle is
 assumed to be massless or stable, respectively.  This is obvious for particles
 such as the photon.  For neutrinos, the mass is meaningless to particle
 physics collider experiments, so it is zero.  For quarks, the $u$ or
 $d$ quark mass is unobservable directly, so we also set it zero.  For
 the heavier quarks, the mass may play a role, so it is kept.  (The $s$
 quark is borderline; one may argue that its mass is also unobservable
 directly.)  On the other hand, the electron mass is relevant, e.g., in
 photon radiation without cuts, so it is not zero by default.
 
 It pays off to set particle masses to zero, if the approximation is justified,
 since fewer helicity states will contribute to the matrix element.  Switching
 off one of the helicity states of an external fermion speeds up the
 calculation by a factor of two.  Therefore, script files will usually contain
 the assignments
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   me = 0  mmu = 0  ms = 0  mc = 0
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 unless they deal with processes where this simplification is
 phenomenologically unacceptable.  Often $m_\tau$ and $m_b$ can also be
 neglected, but this excludes processes where the Higgs couplings of $\tau$ or
 $b$ are relevant.
 
 Setting fermion masses to zero enables, furthermore, the possibility to define
 multi-flavor aliases
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   alias q = d:u:s:c
   alias Q = D:U:S:C
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 and handle processes such as
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   process two_jets_at_ilc = e1, E1 => q, Q
   process w_pairs_at_lhc = q, Q => Wp, Wm
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 where a sum over all allowed flavor combination is automatically included.
 For technical reasons, such flavor sums are possible only for massless
 particles (or more general for mass-degenerate particles). If you want
 to generate inclusive processes with sums over particles of different
 masses (e.g. summing over $W/Z$ in the final state etc.), confer below
 the section about process components, Sec.~\ref{sec:processcomp}.
 
 Assignments of masses, widths and other parameters are actually in effect when
 a process is integrated, not when it is defined.  So, these assignments may
 come before or after the process definition, with no significant difference.
 However, since flavor summation requires masses to be zero, the assignments
 may be put before the alias definition which is used in the process.
 
 The muon, tau, and the heavier quarks are actually unstable.  However, the
 width is set to zero because their decay is a macroscopic effect and, except for
 the muon, affected by hadron physics, so it is not described by \whizard.  (In
 the current \whizard\ setup, all decays occur at the production vertex.  A
 future version may describe hadronic physics and/or macroscopic particle
 propagation, and this restriction may be eventually removed.)
 
 
 
 
 \subsection{Options for processes}
 \label{sec:process options}
 
 The \ttt{process} definition may contain an optional argument:
 \begin{quote}
 \begin{footnotesize}
   \ttt{process \textit{process-id} = \textit{incoming-particles}} \verb|=>|
   \ttt{\textit{outgoing-particles}} \ttt{\{\textit{options\ldots}\}}
 \end{footnotesize}
 \end{quote}
 The \textit{options} are a \sindarin\ script that is executed in a context local
 to the \ttt{process} command.  The assignments it contains apply only to the
 process that is defined. In the following, we describe the set of potentially
 useful options (which all can be also set globally):
 
 \subsubsection{Model reassignment}
 
 It is possible to locally reassign the model via a  \ttt{model =} statment,
 permitting the definition of process using a model other than the globally
 selected model. The process will retain this association during
 integration and event generation.
 
 \subsubsection{Restrictions on matrix elements}
 \label{subsec:restrictions}
 
 Another useful option is the setting
 \begin{quote}
 \begin{footnotesize}
   \verb|$restrictions =| \ttt{\textit{string}}
 \end{footnotesize}
 \end{quote}
 This option allows to select particular classes of Feynman graphs for the
 process when using the \oMega\ matrix element generator.  The
 \verb|$restrictions| string specifies e.g. propagators that the graph
 must contain.  Here is an example:
 \begin{code}
   process zh_invis = e1, E1 => n1:n2:n3, N1:N2:N3, H { $restrictions = "1+2 ~ Z" }
 \end{code}
 The complete process $e^-e^+ \to \nu\bar\nu H$, summed over all neutrino
 generations,  contains both $ZH$ pair production (Higgs-strahlung) and
 $W^+W^-\to H$ fusion.  The restrictions string selects the Higgs-strahlung
 graph where the initial electrons combine to a $Z$ boson.  Here, the particles
 in the process are consecutively numbered, starting with the initial
 particles.  An alternative for the same selection would be
 \verb|$restrictions = "3+4 ~ Z"|.  Restrictions can be combined using
 \verb|&&|, for instance
 \begin{code}
   $restrictions = "1+2 ~ Z && 3 + 4 ~ Z"
 \end{code}
 which is redundant here, however.
 
 The restriction keeps the full energy dependence in the intermediate
 propagator, so the Breit-Wigner shape can be observed in distributions.  This
 breaks gauge invariance, in particular if the intermediate state is off shell,
 so you should use the feature only if you know the implications. For
 more details, cf. the Chap.~\ref{chap:hardint} and the \oMega\ manual.
 
 Other restrictions that can be combined with the restrictions above on
 intermediate propagators allow to exclude certain particles from
 intermediate propagators, or to exclude certain vertices from the
 matrix elements. For example,
 \begin{code}
   process eemm = e1, E1 => e2, E2  { $restrictions = "!A" }
 \end{code}
 would exclude all photon propagators from the matrix element and
 leaves only the $Z$ exchange here. In the same way,
 \verb|$restrictions = "!gl"| would exclude all gluon exchange. This
 exclusion of internal propagators works also for lists of particles,
 like 
 \begin{code}
   $restrictions = "!Z:H"
 \end{code}
 excludes all $Z$ and $H$ propagators from the matrix elements.
 
 Besides excluding certain particles as internal lines, it is also
 possible to exclude certain vertices using the restriction command
 \begin{code}
   process eeww = e1, E1 => Wp, Wm  { $restrictions = "^[W+,W-,Z]" }
 \end{code}
 This would generate the matrix element for the production of two $W$
 bosons at LEP without the non-Abelian vertex $W^+W^-Z$. Again, these
 restrictions are able to work on lists, so
 \begin{code}
   $restrictions = "^[W+,W-,A:Z]"
 \end{code}
 would exclude all triple gauge boson vertices from the above process
 and leave only the $t$-channel neutrino exchange.
 
 It is also possible to exlude vertices by their coupling constants,
 e.g. the photon exchange in the process $e^+ e^- \to \mu^+ \mu^-$ can
 also be removed by the following restriction:
 \begin{code}
   $restrictions = "^qlep"
 \end{code}
 Here, \ttt{qlep} is the \fortran\ variable for the coupling constant
 of the electron-positron-photon vertex.
 
 \begin{table}
   \begin{center}
     \begin{tabular}{|l|l|}
       \hline
       \verb|3+4~Z| & external particles 3 and 4 must come from
       intermediate $Z$ \\\hline
       \verb| && |   & logical ``and'', e.g. in
       \verb| 3+5~t && 4+6~tbar| \\\hline
       \verb| !A | & exclude all $\gamma$ propagators \\\hline
       \verb| !e+:nue | & exclude a list of propagators, here $\gamma$,
       $\nu_e$ \\\hline
       \verb|^qlep:gnclep| & exclude all vertices with
       \ttt{qlep},\ttt{gnclep} coupling constants \\\hline
       \verb|^[A:Z,W+,W-]| & exclude all vertices $W^+W^-Z$,
       $W^+W^-\gamma$ \\\hline
       \verb|^c1:c2:c3[H,H,H]| & exclude all triple Higgs couplings
       with $c_i$ constants
       \\\hline
     \end{tabular}
   \end{center}
   \caption{List of possible restrictions that can be applied to
     \oMega\ matrix elements.}
   \label{tab:restrictions}
 \end{table}
 The Tab.~\ref{tab:restrictions} gives a list of options that can be
 applied to the \oMega\ matrix elements.
 
 
 \subsubsection{Other options}
 
 There are some further options that the \oMega\ matrix-element generator can
 take.  If desired, any string of options that is contained in this variable
 \begin{quote}
 \begin{footnotesize}
   \verb|$omega_flags =| \ttt{\textit{string}}
 \end{footnotesize}
 \end{quote}
 will be copied verbatim to the \oMega\ call, after all other options.
 
 One important application is the scheme of treating the width of unstable
 particles in the $t$-channel.  This is modified by the \verb|model:| class of
 \oMega\ options.
 
 It is well known that for some processes, e.g., single $W$ production from
 photon-$W$ fusion, gauge invariance puts constraints on the treatment of the
 unstable-particle width.  By default, \oMega\ puts a nonzero width in the $s$
 channel only.  This correctly represents the resummed Dyson series for the
 propagator, but it violates QED gauge invariance, although the effect is only
 visible if the cuts permit the photon to be almost on-shell.
 
 An alternative is
 \begin{quote}
 \begin{footnotesize}
   \verb|$omega_flags = "-model:fudged_width"|
 \end{footnotesize}
 \end{quote}
 which puts zero width in the matrix element, so that gauge cancellations
 hold, and reinstates the $s$-channel width in the appropriate places by an
 overall factor that multiplies the whole matrix element.
 
 Another possibility is
 \begin{quote}
 \begin{footnotesize}
   \verb|$omega_flags = "-model:constant_width"|
 \end{footnotesize}
 \end{quote}
 which puts the width both in the $s$ and in the $t$ channel everywhere.
 
 Note that both options apply only to charged unstable particles, such as the
 $W$ boson.
 
 
 \subsubsection{Multithreaded calculation of helicity sums via OpenMP}
 \label{sec:openmp}
 
 On multicore and / or multiprocessor systems, it is possible to speed
 up the calculation by using multiple threads to perform the helicity
 sum in the matrix element calculation. As the processing time used by
 \whizard\ is not used up solely in the matrix element, the speedup thus
 achieved varies greatly depending on the process under consideration;
 while simple processes without flavor sums do not profit significantly
 from this parallelization, the computation time for processes
 involving flavor sums with four or more particles in the final state
 is typically reduced by a factor between two and three when utilizing
 four parallel threads.
 
 The parallization is implemented using \ttt{OpenMP} and requires
 \whizard\ to be compiled with an \ttt{OpenMP} aware compiler and the
 appropiate compiler flags This is done in the configuration step, cf.\
 Sec.~\ref{sec:installation}.
 
 As with all \ttt{OpenMP} programs, the default number of threads used at
 runtime is up to the compiler runtime support and typically set to the
 number of independent hardware threads (cores / processors /
 hyperthreads) available in the system.  This default can be adjusted
 by setting the \ttt{OMP\_NUM\_THREADS} environment variable prior to
 calling WHIZARD.  Alternatively, the available number of threads can
 be reset anytime by the \sindarin\ parameter
 \ttt{openmp\_num\_threads}.  Note however that the total number of
 threads that can be sensibly used is limited by the number of
 nonvanishing helicity combinations.
 
 %%%%%%%%%%%%%%%
 
 \subsection{Process components}
 \label{sec:processcomp}
 
 It was mentioned above that processes with flavor sums (in the initial
 or final state or both) have to be mass-degenerate (in most cases
 massless) in all particles that are summed over at a certain
 position. This condition is necessary in order to use the same
 phase-space parameterization and integration for the flavor-summed
 process. However, in many applications the user wants to handle
 inclusive process definitions, e.g. by defining inclusive decays,
 inclusive SUSY samples at hadron colliders (gluino pairs, squark
 pairs, gluino-squark associated production), or maybe lepton-inclusive
 samples where the tau and muon mass should be kept at different
 values. In \whizard\, from version v2.2.0 on, there is the possibility
 to define such inclusive process containers. The infrastructure for
 this feature is realized via so-called process components: processes
 are allowed to contain several process components. Those components
 need not be provided by the same matrix element generator,
 e.g. internal matrix elements, \oMega\ matrix elements, external
 matrix element (e.g. from a one-loop program, OLP) can be mixed. The
 very same infrastructure can also be used for next-to-leading order
 (NLO) calculations, containing the born with real emission, possible
 subtraction terms to make the several components infrared- and
 collinear finite, as well as the virtual corrections.
 
 Here, we want to discuss the use for inclusive particle samples. There
 are several options, the simplest of which to add up different final
 states by just using the \ttt{+} operator in \sindarin, e.g.:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
    process multi_comp = e1, E1 => (e2, E2) + (e3, E3) + (A, A)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 The brackets are not only used for a better grouping of the expressions,
 they are not mandatory for \whizard\ to interpret the sum
 correctly. When integrating, \whizard\ tells you that this a process
 with three different components:
 \begin{footnotesize}
 \begin{Verbatim}
 | Initializing integration for process multi_comp_1_p1:
 | ------------------------------------------------------------------------
 | Process [scattering]: 'multi_comp'
 |   Library name  = 'default_lib'
 |   Process index = 1
 |   Process components:
 |     1: 'multi_comp_i1':   e-, e+ => m-, m+ [omega]
 |     2: 'multi_comp_i2':   e-, e+ => t-, t+ [omega]
 |     3: 'multi_comp_i3':   e-, e+ => A, A [omega]
 | ------------------------------------------------------------------------
 \end{Verbatim}
 \end{footnotesize}
 A different phase-space setup is used for each different
 component. The integration for each different component is performed
 separately, and displayed on screen. At the end, a sum of all
 components is shown. All files that depend on the components are being
 attached an \ttt{\_i{\em <n>}} where \ttt{{\em <n>}} is the number of
 the process component that appears in the list above: the \fortran\
 code for the matrix element, the \ttt{.phs} file for the phase space
 parameterization, and the grid files for the \vamp\ Monte-Carlo
 integration (or any other integration method). However, there will be
 only one event file for the inclusive process, into which a mixture of
 events according to the size of the individual process component cross
 section enter.
 
 More options are to specify additive lists of particles. \whizard\
 then expands the final states according to tensor product algebra:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
    process multi_tensor = e1, E1 => e2 + e3 + A, E2 + E3 + A
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 This gives the same three process components as above, but \whizard\
 recognized that e.g. $e^- e^+ \to \mu^- \gamma$ is a vanishing
 process, hence the numbering is different:
 \begin{footnotesize}
 \begin{Verbatim}
 | Process component 'multi_tensor_i2': matrix element vanishes
 | Process component 'multi_tensor_i3': matrix element vanishes
 | Process component 'multi_tensor_i4': matrix element vanishes
 | Process component 'multi_tensor_i6': matrix element vanishes
 | Process component 'multi_tensor_i7': matrix element vanishes
 | Process component 'multi_tensor_i8': matrix element vanishes
 | ------------------------------------------------------------------------
 | Process [scattering]: 'multi_tensor'
 |   Library name  = 'default_lib'
 |   Process index = 1
 |   Process components:
 |     1: 'multi_tensor_i1':   e-, e+ => m-, m+ [omega]
 |     5: 'multi_tensor_i5':   e-, e+ => t-, t+ [omega]
 |     9: 'multi_tensor_i9':   e-, e+ => A, A [omega]
 | ------------------------------------------------------------------------
 \end{Verbatim}
 \end{footnotesize}
 Identical copies of the same process that would be created by
 expanding the tensor product of final states are eliminated and appear
 only once in the final sum of process components.
 
 Naturally, inclusive process definitions are also available for
 decays:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 process multi_dec = Wp => E2 + E3, n2 + n3
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 This yields:
 \begin{footnotesize}
 \begin{Verbatim}
 | Process component 'multi_dec_i2': matrix element vanishes
 | Process component 'multi_dec_i3': matrix element vanishes
 | ------------------------------------------------------------------------
 | Process [decay]: 'multi_dec'
 |   Library name  = 'default_lib'
 |   Process index = 2
 |   Process components:
 |     1: 'multi_dec_i1':   W+ => mu+, numu [omega]
 |     4: 'multi_dec_i4':   W+ => tau+, nutau [omega]
 | ------------------------------------------------------------------------
 \end{Verbatim}
 \end{footnotesize}
 
 
 %%%%%%%%%%%%%%%
 
 \subsection{Compilation}
 \label{sec:compilation}
 
 Once processes have been set up, to make them available for integration they
 have to be compiled.  More precisely, the matrix-element generator
 \oMega\ (and it works similarly if a different matrix element method
 is chosen) is called to generate matrix element code, the compiler is
 called to transform this \fortran\ code into object files, and the
 linker is called to collect this in a dynamically loadable library.
 Finally, this library is linked to the program. From version v2.2.0 of
 \whizard\ this is no longer done by system calls of the OS but steered
 via process library Makefiles. Hence, the user can execute and
 manipulate those Makefiles in order to manually intervene in the
 particular steps, if he/she wants to do so.
 
 All this is done automatically when an \ttt{integrate}, \ttt{unstable}, or
 \ttt{simulate} command is encountered for the first time.  You may also force
 compilation explicitly by the command
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   compile
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 which performs all steps as listed above, including loading the generated
 library.
 
 The \fortran\ part of the compilation will be done using the \fortran\ compiler
 specified by the string variable
 \verb|$fc| and the compiler flags specified as \verb|$fcflags|.  The default
 settings are those that have been used for compiling \whizard\ itself during
 installation.  For library compatibility, you should stick to the compiler.
 The flags may be set differently.  They are applied in the compilation and
 loading steps, and they are processed by \ttt{libtool}, so
 \ttt{libtool}-specific flags can also be given.
 
 \whizard\ has some precautions against unnecessary repetitions.  Hence, when a
 \ttt{compile} command is executed (explicitly, or implicitly by the first
 integration), the program checks first whether the library is already loaded,
 and whether source code already exists for the requested processes.  If yes,
 this code is used and no calls to \oMega\ (or another matrix element
 method) or to the compiler are issued.
 Otherwise, it will detect any modification to the process configuration and
 regenerate the matrix element or recompile accordingly.  Thus, a \sindarin\
 script can be executed repeatedly without rebuilding everything from scratch,
 and you can safely add more processes to a script in a subsequent run without
 having to worry about the processes that have already been treated.
 
 This default behavior can be changed.  By setting
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   ?rebuild_library = true
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 code will be re-generated and re-compiled even if \whizard\ would think that
 this is unncessary.  The same effect is achieved by calling \whizard\ with a
 command-line switch,
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   /home/user$ whizard --rebuild_library
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 There are further \ttt{rebuild} switches which are described below.  If
 everything is to be rebuilt, you can set a master switch \ttt{?rebuild} or the
 command line option \verb|--rebuild|.  The latter can be abbreviated as a short
 command-line option:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   /home/user$ whizard -r
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Setting this switch is always a good idea when starting a new project, just in
 case some old files clutter the working directory.  When re-running the same
 script, possibly modified, the \verb|-r| switch should be omitted, so the
 existing files can be reused.
 
 
 
 \subsection{Process libraries}
 
 Processes are collected in \emph{libraries}.  A script may use more than one
 library, although for most applications a single library will probably be
 sufficient.
 
 The default library is \ttt{default\_lib}.  If you do not specify anything else,
 the processes you compile will be collected by a driver file
 \ttt{default\_lib.f90} which is compiled together with the process code and
 combined as a libtool archive \ttt{default\_lib.la}, which is dynamically linked
 to the running \whizard\ process.
 
 Once in a while, you work on several projects at once, and you didn't care
 about opening a new working directory for each.  If the \verb|-r| option is
 given, a new run will erase the existing library, which may contain processes
 needed for the other project.  You could omit \verb|-r|, so all processes will
 be collected in the same library (this does not hurt), but you may wish to
 cleanly separate the projects.  In that case, you should open a separate
 library for each project.
 
 Again, there are two possibilities.  You may start the script with the
 specification
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   library = "my_lhc_proc"
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 to open a library \verb|my_lhc_proc| in place of the default library.
 Repeating the command with different arguments, you may introduce several
 libraries in the script.  The active library is always the one specified
 last.  It is possible to issue this command locally, so a particular process
 goes into its own library.
 
 Alternatively, you may call \whizard\ with the option
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   /home/user$ whizard --library=my_lhc_proc
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 
 If several libraries are open simultaneously, the \ttt{compile} command will
 compile all libraries that the script has referenced so far.  If this is not
 intended, you may give the command an argument,
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   compile ("my_lhc_proc", "my_other_proc")
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 to compile only a specific subset.
 
 The command
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   show (library)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 will display the contents of the actually loaded library together with
 a status code which indicates the status of the library and the processes within.
 
 %%%%%%%%%%%%%%%
 
 \subsection{Stand-alone \whizard\ with precompiled processes}
 \label{sec:static}
 
 Once you have set up a process library, it is straightforward to make a
 special stand-alone \whizard\ executable which will have this library
 preloaded on startup.  This is a matter of convenience, and it is also useful
 if you need a statically linked executable for reasons of profiling,
 batch processing, etc.
 
 For this task, there is a variant of the \ttt{compile} command:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   compile as "my_whizard" ()
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 which produces an executable \verb|my_whizard|.  You can omit the library
 argument if you simply want to include everything.  (Note that this command
 will \emph{not} load a library into the current process, it is intended for
 creating a separate program that will be started independently.)
 
 As an example, the script
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   process proc1 = e1, E1 => e1, E1
   process proc2 = e1, E1 => e2, E2
   process proc3 = e1, E1 => e3, E3
   compile as "whizard-leptons" ()
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 will make a new executable program \verb|whizard-leptons|.  This
 program behaves completely identical to vanilla \whizard, except for the fact
 that the processes \ttt{proc1}, \ttt{proc2}, and \ttt{proc3} are available
 without configuring them or loading any library.
 
 % This feature is particularly useful when compiling with the \ttt{-static}
 % flag.  As long as the architecture is compatible, the resulting binary may be
 % run on a different computer where no \whizard\ libraries are present.  (The
 % program will still need to find its model files, however.)
 
 
 
 \section{Beams}
 \label{sec:beams}
 
 Before processes can be integrated and simulated, the program has to know
 about the collider properties.  They can be specified by the \ttt{beams}
 statement.
 
 In the command script, it is irrelevant whether a \ttt{beams} statement comes
 before or after process specification.  The \ttt{integrate} or \ttt{simulate}
 commands will use the \ttt{beams} statement that was issued last.
 
 
 \subsection{Beam setup}
 \label{sec:beam-setup}
 
 If the beams have no special properties, and the colliding particles are the
 incoming particles in the process themselves, there is no need for a
 \ttt{beams} statement at all.  You only \emph{must} specify the
 center-of-momentum energy of the collider by setting the value of $\sqrt{s}$,
 for instance
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   sqrts = 14 TeV
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 The \ttt{beams} statement comes into play if
 \begin{itemize}
 \item
   the beams have nontrivial structure, e.g., parton structure in hadron
   collision or photon radiation in lepton collision, or
 \item
   the beams have non-standard properties: polarization, asymmetry, crossing
   angle.
 \end{itemize}
 Note that some of the abovementioned beam properties had not yet been
 reimplemented in the \whizard\ttt{2} release series. From version
 v2.2.0 on all options of the legacy series \whizard\ttt{1} are
 available again. From version v2.1 to version v2.2 of \whizard\ there
 has also been a change in possible options to the \ttt{beams}
 statement: in the early versions of \whizard\ttt{2} (v2.0/v2.1), local
 options could be specified within the beam settings, e.g. \ttt{beams =
 p, p { sqrts = 14 TeV } => pdf\_builtin}. These possibility has been
 abandoned from version v2.2 on, and the \ttt{beams} command does not
 allow for {\em any} optional arguments any more.
 
 Hence, beam parameters can -- with the exception of the specification
 of structure functions -- be specified only globally:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   sqrts = 14 TeV
   beams = p, p => lhapdf
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 It does not make any difference whether the value of \ttt{sqrts} is
 set before or after the \ttt{beams} statement, the last value found
 before an \ttt{integrate} or \ttt{simulate} is the relevant one. This
 in particularly allows to specify the beam structure, and then after
 that perform a loop or scan over beam energies, beam parameters, or
 structure function settings.
 
 The \ttt{beams} statement also applies to particle decay processes, where there
 is only a single beam.  Here, it is usually redundant because no structure
 functions are possible, and the energy is fixed to the decaying particle's
 mass.  However, it is needed for computing polarized decay, e.g.
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   beams = Z
   beams_pol_density = @(0)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 where for a boson at rest, the polarization axis is defined to be the $z$
 axis.
 
 Beam polarization is described in detail below in Sec.~\ref{sec:polarization}.
 
 Note also that future versions of \whizard\ might give support for
 single-beam events, where structure functions for single particles
 indeed do make sense.
 
 In the following sections we list the available options for structure
 functions or spectra inside \whizard\ and explain their usage. More
 about the physics of the implemented structure functions can be found
 in Chap.~\ref{chap:hardint}.
 
 %%%%%%%%%%%%%%%
 
 \subsection{Asymmetric beams and Crossing angles}
 \label{sec:asymmetricbeams}
 
 \whizard\ not only allows symmetric beam collisions, but basically
 arbitrary collider setups. In the case there are two different beam
 energies, the command
 \begin{quote}
 \begin{footnotesize}
   \ttt{beams\_momentum = {\em <beam\_mom1>}, {\em <beam\_mom2>}}
 \end{footnotesize}
 \end{quote}
 allows to specify the momentum (or as well energies for massless
 particles) for the beams. Note that for scattering processes both
 values for the beams must be present. So the following to setups for
 14 TeV LHC proton-proton collisions are equivalent:
 \begin{quote}
 \begin{footnotesize}
   \ttt{beams = p, p => pdf\_builtin} \newline
   \ttt{sqrts = 14 TeV}
 \end{footnotesize}
 \end{quote}
 and
 \begin{quote}
 \begin{footnotesize}
   \ttt{beams = p, p => pdf\_builtin} \newline
   \ttt{beams\_momentum = 7 TeV, 7 TeV}
 \end{footnotesize}
 \end{quote}
 Asymmetric setups can be set by using different values for the two
 beam momenta, e.g. in a HERA setup:
 \begin{quote}
 \begin{footnotesize}
   \ttt{beams = e, p => none, pdf\_builtin}
   \ttt{beams\_momentum = 27.5 GeV, 920 GeV}
 \end{footnotesize}
 \end{quote}
 or for the BELLE experiment at the KEKB accelerator:
 \begin{quote}
 \begin{footnotesize}
   \ttt{beams = e1, E1}
   \ttt{beams\_momentum = 8 GeV, 3.5 GeV}
 \end{footnotesize}
 \end{quote}
 \whizard\ lets you know about the beam structure and calculates for
 you that the center of mass energy corresponds to 10.58 GeV:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 | Beam structure: e-, e+
 |   momentum = 8.000000000000E+00, 3.500000000000E+00
 | Beam data (collision):
 |   e-  (mass = 5.1099700E-04 GeV)
 |   e+  (mass = 5.1099700E-04 GeV)
 |   sqrts = 1.058300530253E+01 GeV
 | Beam structure: lab and c.m. frame differ
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 
 It is also possible to specify beams for decaying particles, where
 \ttt{beams\_momentum} then only has a single argument, e.g.:
 \begin{quote}
 \begin{footnotesize}
   \ttt{process zee = Z => "e-", "e+"} \\
   \ttt{beams = Z} \\
   \ttt{beams\_momentum = 500 GeV} \\
   \ttt{simulate (zee) \{ n\_events = 100 \} }
 \end{footnotesize}
 \end{quote}
 This would corresponds to a beam of $Z$ bosons with a momentum of 500
 GeV. Note, however, that \whizard\ will always do the integration of
 the particle width in the particle's rest frame, while the moving beam
 is then only taken into account for the frame of reference for the
 simulation.
 
 Further options then simply having different beam energies describe a
 non-vanishing between the two incoming beams. Such concepts are quite
 common e.g. for linear colliders to improve the beam properties in the
 collimation region at the beam interaction points. Such crossing
 angles can be specified in the beam setup, too, using the
 \ttt{beams\_theta} command:
 \begin{quote}
 \begin{footnotesize}
   \ttt{beams = e1, E1} \\
   \ttt{beams\_momentum = 500 GeV, 500 GeV} \\
   \ttt{beams\_theta = 0, 10 degree}
 \end{footnotesize}
 \end{quote}
 It is important that when a crossing angle is being specified, and the
 collision system consequently never is the center-of-momentum system,
 the beam momenta have to explicitly set. Besides a planar crossing
 angle, one is even able to rotate an azimuthal distance:
 \begin{quote}
 \begin{footnotesize}
   \ttt{beams = e1, E1} \\
   \ttt{beams\_momentum = 500 GeV, 500 GeV} \\
   \ttt{beams\_theta = 0, 10 degree} \\
   \ttt{beams\_phi = 0, 45 degree}
 \end{footnotesize}
 \end{quote}
 
 %%%%%%%%%%%%%%%
 
 \subsection{LHAPDF}
 \label{sec:lhapdf}
 
 For incoming hadron beams, the \ttt{beams} statement specifies which structure
 functions are used.  The simplest example is the study of parton-parton
 scattering processes at a hadron-hadron collider such as LHC or Tevatron.  The
 \lhapdf\ structure function set is selected by a syntax similar to the
 process setup, namely the example already shown above:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   beams = p, p => lhapdf
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Note that there are slight differences in using the \lhapdf\ release
 series 6 and the older \fortran\ \lhapdf\ release series 5, at least
 concerning the naming conventions for the PDF sets~\footnote{Until
   \whizard\ version 2.2.1 including, only the \lhapdf\ series 5 was
   supported, while from version 2.2.2 on also the \lhapdf\ release
   series 6 has been supported.}. The above \ttt{beams}
 statement selects a default \lhapdf\ structure-function set for both
 proton beams (which is the \ttt{CT10} central set for \lhapdf\ 6, and
 \ttt{cteq6ll.LHpdf} central set for \lhapdf 5).  The structure
 function will apply for all quarks, antiquarks, and the gluon as far
 as supported by the particular \lhapdf\ set.  Choosing a different set
 is done by adding the  filename as a local option to the \ttt{lhapdf}
 keyword:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   beams = p, p => lhapdf
   $lhapdf_file = "MSTW2008lo68cl"
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 for the actual \lhapdf\ 6 series, and
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   beams = p, p => lhapdf
   $lhapdf_file = "MSTW2008lo68cl.LHgrid"
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 for \lhapdf 5.Similarly, a member within the set is selected by the
 numeric variable \verb|lhapdf_member| (for both release series of \lhapdf).
 
 In some cases, different structure functions have to be chosen for the two
 beams.  For instance, we may look at $ep$ collisions:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   beams = "e-", p => none, lhapdf
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Here, there is a list of two independent structure functions (each with its
 own option set, if applicable) which applies to the two beams.
 
 Another mixed case is $p\gamma$ collisions, where the photon is to be
 resolved as a hadron.  The simple assignment
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   beams = p, gamma => lhapdf, lhapdf_photon
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 will be understood as follows: \whizard\ selects the appropriate default
 structure functions (here we are using \lhapdf\ 5 as an example as the
 support of photon and pion PDFs in \lhapdf\ 6 has been dropped),
 \ttt{cteq6ll.LHpdf} for the proton and
 \ttt{GSG960.LHgrid} for the photon.  The photon case has an additional
 integer-valued parameter \verb|lhapdf_photon_scheme|.  (There are also pion
 structure functions available.)  For modifying the default, you have to
 specify separate structure functions
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   beams = p, gamma => lhapdf, lhapdf_photon
   $lhapdf_file = ...
   $lhapdf_photon_file = ...
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Finally, the scattering of elementary photons on partons is described by
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   beams = p, gamma => lhapdf, none
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 
 Note that for \lhapdf\ version 5.7.1 or higher and for PDF sets which
 support it, photons can be used as partons.
 
 There is one more option for the \lhapdf\ PDFs, namely to specify the
 path where the \lhapdf\ PDF sets reside: this is done with the string
 variable \ttt{\$lhapdf\_dir = "{\em <path-to-lhapdf>}"}. Usually, it
 is not necessary to set this because \whizard\ detects this path via
 the \ttt{lhapdf-config} script during configuration, but in the case
 paths have been moved, or special files/special locations are to be
 used, the user can specify this location explicitly.
 
 %%%%%%%%%%%%%%%
 
 \subsection{Built-in PDFs}
 \label{sec:built-in-pdf}
 
 In addition to the possibility of linking against \lhapdf, \whizard\
 comes with a couple of built-in PDFs which are selected via the
 \verb?pdf_builtin? keyword
 %
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   beams = p, p => pdf_builtin
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 %
 
 The default PDF set is CTEQ6L, but other choices are also available by
 setting the string variable \verb?$pdf_builtin_set? to an
 appropiate value. E.g, modifying the above
 setup to
 %
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   beams = p, p => pdf_builtin
   $pdf_builtin_set = "mrst2004qedp"
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 %
 would select the proton PDF from the MRST2004QED set. A list of all currently
 available PDFs can be found in Table~\ref{tab:pdfs}.
 %
 \begin{table}
 \centerline{\begin{tabular}{|l||l|p{0.2\textwidth}|l|}
 \hline
 Tag & Name & Notes & References \\\hline\hline
 %
 \ttt{cteq6l} & CTEQ6L & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Pumplin:2002vw} \\\hline
 \ttt{cteq6l1} & CTEQ6L1 & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Pumplin:2002vw} \\\hline
 \ttt{cteq6d} & CTEQ6D & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Pumplin:2002vw} \\\hline
 \ttt{cteq6m} & CTEQ6M & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Pumplin:2002vw} \\\hline
 \hline
 \ttt{mrst2004qedp} & MRST2004QED (proton) & includes photon &
    \cite{Martin:2004dh} \\\hline
 \hline
 \ttt{mrst2004qedn} & MRST2004QED (neutron) & includes photon &
    \cite{Martin:2004dh} \\\hline
 \hline
 \ttt{mstw2008lo} & MSTW2008LO & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Martin:2009iq} \\\hline
 \ttt{mstw2008nlo} & MSTW2008NLO & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Martin:2009iq} \\\hline
 \ttt{mstw2008nnlo} & MSTW2008NNLO & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Martin:2009iq} \\\hline
 \hline
 \ttt{ct10} & CT10 & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Lai:2010vv} \\\hline
 \hline
 \ttt{CJ12\_max} & CJ12\_max & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Owens:2012bv} \\\hline
 \ttt{CJ12\_mid} & CJ12\_mid & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Owens:2012bv} \\\hline
 \ttt{CJ12\_min} & CJ12\_min & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Owens:2012bv} \\\hline
 \hline
 \ttt{CJ15LO} & CJ15LO & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Accardi:2016qay} \\\hline
 \ttt{CJ15NLO} & CJ15NLO & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Accardi:2016qay} \\\hline
 \hline
 \ttt{mmht2014lo} & MMHT2014LO & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Harland-Lang:2014zoa} \\\hline
 \ttt{mmht2014nlo} & MMHT2014NLO & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Harland-Lang:2014zoa} \\\hline
 \ttt{mmht2014nnlo} & MMHT2014NNLO & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Harland-Lang:2014zoa} \\\hline
 \hline
 \ttt{CT14LL} & CT14LLO & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Dulat:2015mca} \\\hline
 \ttt{CT14L} & CT14LO & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Dulat:2015mca} \\\hline
 \ttt{CT14N} & CT1414NLO & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Dulat:2015mca} \\\hline
 \ttt{CT14NN} & CT14NNLO & \mbox{}\hfill---\hfill\mbox{} &
    \cite{Dulat:2015mca} \\\hline
 \hline
 %
 \end{tabular}}
 \caption{All PDF sets available as builtin sets. The two MRST2004QED
   sets also contain a photon.}
 \label{tab:pdfs}
 \end{table}
 
 The two MRST2004QED sets also contain the photon as a parton, which
 can be used in the same way as for \lhapdf\ from v5.7.1 on. Note,
 however, that there is no builtin PDF that contains a photon structure
 function. There is a \ttt{beams} structure function specifier
 \ttt{pdf\_builtin\_photon}, but at the moment this throws an error. It
 just has been implemented for the case that in future versions of
 \whizard\ a photon structure function might be included.
 
 Note that in general only the data sets for the central values of the
 different PDFs ship with \whizard. Using the error sets is possible,
 i.e. it is supported in the syntax of the code, but you have to
 download the corresponding data sets from the web pages of the PDF
 fitting collaborations.
 
 %%%%%%%%%%%%%%%
 
 \subsection{HOPPET $b$ parton matching}
 
 When the \hoppet\ tool~\cite{Salam:2008qg} for hadron-collider PDF
 structure functions and their manipulations are
 correctly linked to \whizard, it can be used for advanced
 calculations and simulations of hadron collider physics. Its main
 usage inside \whizard\ is for matching schemes between 4-flavor and
 5-flavor schemes in $b$-parton initiated processes at hadron
 colliders. Note that in versions 2.2.0 and 2.2.1 it only worked
 together with \lhapdf\ version 5, while with the \lhapdf\ version 6
 interface from version 2.2.2 on it can be used also with the modern
 version of PDFs from \lhapdf. Furthermore, from version 2.2.2, the
 \hoppet\ $b$ parton matching also works for the builtin PDFs.
 
 It depends on the corresponding process and the energy scales involved
 whether it is a better description to use the
 $g\to b\bar b$ splitting from the DGLAP evolution inside the PDF and
 just take the $b$ parton content of a PDF, e.g. in BSM Higgs
 production for large $\tan\beta$: $pp \to H$ with a partonic
 subprocess $b\bar b \to H$, or directly take the gluon PDFs and use
 $pp \to b\bar b H$ with a partonic subprocess $gg \to b \bar b
 H$. Elaborate schemes for a proper matching between the two
 prescriptions have been developed and have been incorporated into the
 \hoppet\ interface.
 
 Another prime example for using these matching schemes is single top
 production at hadron colliders. Let us consider the following setup:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 process proc1 = b, u => t, d
 process proc2 = u, b => t, d
 process proc3 = g, u => t, d, B	{ $restrictions = "2+4 ~ W+" }
 process proc4 = u, g => t, d, B	{ $restrictions = "1+4 ~ W+" }
 
 beams = p,p => pdf_builtin
 sqrts = 14 TeV
 ?hoppet_b_matching = true
 
 $sample = "single_top_matched"
 luminosity = 1 / 1 fbarn
 simulate (proc1, proc2, proc3, proc4)
 \end{Verbatim}
 \end{footnotesize}%$
 \end{quote}
 The first two processes are single top production from $b$ PDFs, the
 last two processes contain an explicit $g\to b\bar b$ splitting (the
 restriction, cf. Sec.~\ref{sec:process options} has been placed in
 order to single out the single top production signal process). PDFs
 are then chosen from the default builtin PDF (which is \ttt{CTEQ6L}),
 and the \hoppet\ matching routines are switched on by the flag
 \ttt{?hoppet\_b\_matching}.
 
 %%%%%%%%%%%%%%%
 
 \subsection{Lepton Collider ISR structure functions}
 \label{sec:lepton_isr}
 
 Initial state QED radiation off leptons is an important feature at all
 kinds of lepton colliders: the radiative return to the $Z$ resonance
 by ISR radiation was in fact the largest higher-order effect for the
 SLC and LEP I colliders. The soft-collinear and soft photon radiation
 can indeed be resummed/exponentiated to all orders in perturbation
 theory~\cite{Gribov:1972rt}, while higher orders in hard-collinear
 photons have to be explicitly calculated order by
 order~\cite{Kuraev:1985hb,Skrzypek:1990qs}. \whizard\ has an intrinsic
 implementation of the lepton ISR structure function that includes all
 orders of soft and soft-collinear photons as well as up to the third
 order in hard-collinear photons. It can be switched on by the
 following statement:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 beams = e1, E1 => isr
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 As the ISR structure function is a single-beam structure function,
 this expression is synonymous for
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 beams = e1, E1 => isr, isr
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 The ISR structure function can again be applied to only one of the two
 beams, e.g. in a HERA-like setup:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 beams = e1, p => isr, pdf_builtin
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 
 Their are several options for the lepton-collider ISR structure
 function that are summarized in the following:
 
 \vspace{2mm}
 
 \centerline{\begin{tabular}{|l|l|l|}\hline
 Parameter & Default & Meaning \\\hline\hline
 \ttt{isr\_alpha} & \ttt{0}/intrinsic & value of $\alpha_{QED}$ for ISR
 \\\hline
 \ttt{isr\_order} & \ttt{3} & max. order of hard-collinear photon
 emission \\\hline
 \ttt{isr\_mass} & \ttt{0}/intrinsic & mass of the radiating lepton  \\\hline
 \ttt{isr\_q\_max} & \ttt{0}/$\sqrt{s}$ & upper cutoff for ISR \\\hline
 \hline
 \ttt{?isr\_recoil} & \ttt{false} & flag to switch on recoil/$p_T$
 (\emph{deprecated})\\\hline
 \ttt{?isr\_keep\_energy} & \ttt{false} & recoil flag: conserve
 energy in splitting (\emph{deprecated})
 \\\hline
 \end{tabular}}\mbox{}
 
 The maximal order of the hard-collinear photon emission taken into
 account by \whizard\ is set by the integer variable \ttt{isr\_order};
 the default is the maximally available order of three. With the
 variable \ttt{isr\_alpha}, the value of the QED coupling constant
 $\alpha_{QED}$ used in the ISR structure function can be set. The
 default is taken from the active physics model. The mass of the
 radiating lepton (in most cases the electron) is set by
 \ttt{isr\_mass}; again the default is taken from the active physics
 model. Furthermore, the upper integration border for the ISR structure
 function which acts roughly as an upper hardness cutoff for the emitted
 photons, can be set through \ttt{isr\_q\_max}; if not set, the
 collider energy (possibly after beamstrahlung,
 cf. Sec.~\ref{sec:beamstrahlung}) $\sqrt{s}$ (or $\sqrt{\widehat{s}}$)
 is taken.  Note that \whizard\ accounts for the
 exclusive effects of ISR radiation at the moment by a single (hard,
 resolved) photon in the event; a more realistic treatment of exclusive
 ISR photons in simulation is foreseen for a future version.
 
 While the ISR structure function is evaluated in the collinear limit,
 it is possible to generate transverse momentum for both the radiated
 photons and the recoiling partonic system.  We recommend to stick to
 the collinear approximation for the integration step.  Integration
 cuts should be set up such that they do not significantly depend on
 photon transverse momentum.  In a subsequent simulation step, it is
 possible to transform the events with collinear ISR radiation into
 more realistic events with non-collinear radiation.  To this end,
 \whizard\ provides a separate ISR photon handler which can be
 activated in the simulation step.  The algorithm operates on the
 partonic event: it takes the radiated photons and the partons entering
 the hard process, and applies a $p_T$ distribution to those particles
 and their interaction products, i.e., all outgoing particles.  Cuts
 that depend on photon $p_T$ may be applied to the modified events.
 For details on the ISR photon handler,
 cf.\ Sec.~\ref{sec:isr-photon-handler}.
 
 {\footnotesize The flag \ttt{?isr\_recoil} switches on $p_T$ recoil of
   the emitting lepton against photon radiation during integration; per
   default it is off.  The flag \ttt{?isr\_keep\_energy} controls the
   mode of on-shell projection for the splitting process with $p_T$.
   Note that this feature is kept for backwards compatibility, but
   should not be used for new simulations.  The reason is as follows:
   For a fraction of events, $p_T$ will become significant, and (i)
   energy/momentum non-conservation, applied to both beams separately,
   can lead to unexpected and unphysical effects, and (ii) the modified
   momenta enter the hard process, so the collinear approximation used
   in the ISR structure function computation does not hold.  }
 
 %%%%%%%%%%%%%%%
 
 \subsection{Lepton Collider Beamstrahlung}
 \label{sec:beamstrahlung}
 
 At linear lepton colliders, the macroscopic electromagnetic
 interaction of the bunches leads to a distortion of the spectrum of
 the bunches that is important for an exact simulation of the beam
 spectrum. There are several methods to account for these effects. The
 most important tool to simulate classical beam-beam interactions in
 lepton-collider physics is
 \ttt{GuineaPig++}~\cite{Schulte:1998au,Schulte:1999tx,Schulte:2007zz}. A
 direct interface between this tool \ttt{GuineaPig++} and \whizard\ had
 existed as an inofficial add-on to the legacy branch \whizard\ttt{1},
 but is no longer applicable in \whizard\ttt{2}. A \whizard-internal
 interface is foreseen for the very near future, most probably within
 this v2.2 release. Other options are to use parameterizations of the
 beam spectrum that have been included in the package \circeone~\cite{CIRCE}
 which has been interfaced to \whizard\ since version v1.20 and been
 included in the \whizard\ttt{2} release series. Another option is to
 generate a beam spectrum externally and then read it in as an ASCII
 data file, cf. Sec.~\ref{sec:beamevents}. More about this can be found
 in a dedicated section on lepton collider spectra,
 Sec.~\ref{sec:beamspectra}.
 
 In this section, we discuss the usage of beamstrahlung spectra by
 means of the \circeone\ package. The beamstrahlung spectra are
 true spectra, so they have to be applied to pairs of beams, and an
 application to only one beam is meaningless. They are switched on by
 this \ttt{beams} statement including structure functions:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 beams = e1, E1 => circe1
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 It is important to note that the parameterization of the beamstrahlung
 spectra within \circeone\ contain also processes where $e\to\gamma$
 conversions have been taking place, i.e. also hard processes with one
 (or two) initial photons can be simulated with beamstrahlung switched
 on. In that case, the explicit photon flags, \ttt{?circe1\_photon1}
 and \ttt{?circe1\_photon2}, for the two beams have to be properly set,
 e.g. (ordering in the final state does not play a role):
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 process proc1 = A, e1 => A, e1
 sqrts = 500 GeV
 beams = e1, E1 => circe1
 ?circe1_photon1 = true
 integrate (proc1)
 
 process proc2 = e1, A => A, e1
 sqrts = 1000 GeV
 beams = e1, A => circe1
 ?circe1_photon2 = true
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 or
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 process proc1 = A, A => Wp, Wm
 sqrts = 200 GeV
 beams = e1, E1 => circe1
 ?circe1_photon1 = true
 ?circe1_photon2 = true
 ?circe1_generate = false
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 In all cases (one or both beams with photon conversion) the beam
 spectrum applies to both beams simultaneously.
 
 In the last example ($\gamma\gamma\to W^+W^-$) the default
 \circeone\ generator mode was turned off by unsetting
 \verb|?circe1_generate|.  In the other examples this flag is
 set, by default.  For standard use cases,
 \circeone\ implements a beam-event generator inside the
 \whizard\ generator, which provides beam-event samples with correctly
 distributed probability.  For electrons, the beamstrahlung spectrum
 sharply peaks near maximum energy.  This distribution is most
 efficiently handled by the generator mode.  By contrast, in the $\gamma\gamma$
 mode, the beam-event c.m.\ energy is concentrated at low values.  For
 final states with low invariant mass, which are typically produced by
 beamstrahlung photons, the generator mode is appropriate.
 However, the $W^+W^-$ system requires substantial energy, and such
 events will be very rare in the beam-event sample.  Switching off the
 \circeone\ generator mode solves this
 problem.
 
 This is an overview over all options and flags for the \circeone\
 setup for lepton collider beamstrahlung:
 
 \vspace{2mm}
 
 \centerline{\begin{tabular}{|l|l|l|}\hline
 Parameter & Default & Meaning \\\hline\hline
 \ttt{?circe1\_photon1} & \ttt{false} & $e\to\gamma$ conversion for beam 1
 \\\hline
 \ttt{?circe1\_photon2} & \ttt{false} & $e\to\gamma$ conversion for beam 2
 \\\hline
 \ttt{circe1\_sqrts} & $\sqrt{s}$ & collider energy for the beam spectrum  \\\hline
 \ttt{?circe1\_generate} & \ttt{true} & flag for the \circeone\ generator mode \\\hline
 \ttt{?circe1\_map} & \ttt{true} & flag to apply special phase-space mapping
 \\\hline
 \ttt{circe1\_mapping\_slope} & \ttt{2.} & value of PS mapping exponent
 \\\hline
 \ttt{circe1\_eps} & \ttt{1E-5} & parameter for mapping of spectrum peak
 position \\\hline
 \ttt{circe1\_ver} & \ttt{0} & internal version of \circeone\ package
 \\\hline
 \ttt{circe1\_rev} & \ttt{0}/most recent & internal revision of
 \circeone\ \\\hline
 \ttt{\$circe1\_acc} & \ttt{SBAND} & accelerator type \\\hline
 \ttt{circe1\_chat} & \ttt{0} & chattiness/verbosity of \circeone \\\hline
 \end{tabular}}\mbox{}
 
 The collider energy relevant for the beamstrahlung spectrum is set by
 \ttt{circe1\_sqrts}. As a default, this is always the value of
 \ttt{sqrts} set in the \sindarin\ script. However, sometimes these
 values do not match, e.g. the user wants to simulate $t\bar t h$ at
 \ttt{sqrts = 550 GeV}, but the only available beam spectrum is for 500
 GeV. In that case, \ttt{circe1\_sqrts = 500 GeV} has to be set to use
 the closest possible available beam spectrum.
 
 As mentioned in the discussion of the examples above, in
 \circeone\ there are two options to use the beam spectra for
 beamstrahlung: intrinsic semi-analytic approximation formulae for the
 spectra, or a Monte-Carlo sampling of the sampling. The second
 possibility always give a better description of the spectra, and is
 the default for \whizard. It can, however, be switched off by setting
 the flag \ttt{?circe1\_generate} to \ttt{false}.
 
 As the beamstrahlung spectra are sharply peaked at the collider
 energy, but still having long tails, a mapping of the spectra for an
 efficient phase-space sampling is almost mandatory. This is the
 default in \whizard, which can be changed by the flag
 \ttt{?circe1\_map}. Also, the default exponent for the mapping can be
 changed from its default value \ttt{2.} with the variable
 \ttt{circe1\_mapping\_slope}. It is important to efficiently sample
 the peak position of the spectrum; the effective ratio of the peak to
 the whole sampling interval can be set by the parameter
 \ttt{circe1\_eps}. The integer parameter \ttt{circe1\_chat} sets the
 chattiness or verbosity of the \circeone\ package, i.e. how many
 messages and warnings from the beamstrahlung generation/sampling will
 be issued.
 
 The actual internal version and revision of the \circeone\ package are
 set by the two integer parameters \ttt{circe1\_ver} and
 \ttt{circe1\_rev}. The default is in any case always the newest
 version and revision, while older versions are still kept for
 backwards compatibility and regression testing.
 
 Finally, the geometry and design of the accelerator type is set with
 the string variable \ttt{\$circe1\_acc}: it contains the possible
 options for the old \ttt{"SBAND"} and \ttt{"XBAND"} setups, as well as
 the \ttt{"TESLA"} and JLC/NLC SLAC design \ttt{"JLCNLC"}. The setups
 for the most important energies of the ILC as they are summarized in
 the ILC
 TDR~\cite{Behnke:2013xla,Baer:2013cma,Adolphsen:2013jya,Adolphsen:2013kya}
 are available as \ttt{ILC}. Beam spectra for the
 CLIC~\cite{Aicheler:2012bya,Lebrun:2012hj,Linssen:2012hp} linear
 collider are much more demanding to correctly simulate (due to the
 drive beam concept; only the low-energy modes where the drive beam is
 off can be simulated with the same setup as the abovementioned
 machines). Their setup will be supported soon in one of the upcoming
 \whizard\ versions within the \circetwo\ package.
 
 An example of how to generate beamstrahlung spectra with the help of
 the package \circetwo\ (that is also a part of \whizard) is this:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 process eemm = e1, E1 => e2, E2
 sqrts = 500 GeV
 beams = e1, E1 => circe2
 $circe2_file = "ilc500.circe"
 $circe2_design = "ILC"
 ?circe_polarized = false
 \end{Verbatim}
 \end{footnotesize}%$
 \end{quote}
 Here, the ILC design is used for a beamstrahlung spectrum at 500 GeV
 nominal energy, with polarization averaged (hence, the setting of
 polarization to \ttt{false}). A list of all available options can be
 found in Sec.~\ref{sec:photoncoll}.
 
 More technical details about the simulation of beamstrahlung spectra
 see the documented source code of the \circeone\ package, as well as
 Chap.~\ref{chap:hardint}. In the next section, we discuss how to read
 in beam spectra from external files.
 
 %%%%%%%%%%%%%%%
 
 \subsection{Beam events}
 \label{sec:beamevents}
 
 As mentioned in the previous section, beamstrahlung is one of the
 crucial ingredients for a realistic simulation of linear lepton
 colliders. One option is to take a pre-generated beam spectrum for
 such a machine, and make it available for simulation within \whizard\
 as an external ASCII data file. Such files basically contain only
 pairs of energy fractions of the nominal collider energy $\sqrt{s}$
 ($x$ values). In \whizard\ they can be used in simulation with the
 following \ttt{beams} statement:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 beams = e1, E1 => beam_events
 $beam_events_file = "<beam_spectrum_file>"
 \end{Verbatim}
 \end{footnotesize}%$
 \end{quote}
 Note that beam spectra must always be pair spectra, i.e. they are
 automatically applied to both beam simultaneously.
 Beam spectra via external files are expected to reside in the current
 working directory. Alternatively, \whizard\ searches for them in the
 install directory of \whizard\ in \ttt{share/beam-sim}. There you can
 find an example file, \ttt{uniform\_spread\_2.5\%.dat} for such a beam
 spectrum. The only possible parameter that can be set is the flag
 \ttt{?beam\_events\_warn\_eof} whose default is \ttt{true}. This
 triggers the issuing of a warning when the end of file of an external
 beam spectrum file is reached. In such a case, \whizard\ starts to
 reuse the same file again from the beginning. If the available data
 points in the beam events file are not big enough, this could result
 in an insufficient sampling of the beam spectrum.
 
 %%%%%%%%%%%%%%%
 
 \subsection{Gaussian beam-energy spread}
 \label{sec:gaussian}
 
 Real beams have a small energy spread.  If beamstrahlung is small, the spread
 may be approximately described as Gaussian.  As a replacement for the full
 simulation that underlies \ttt{CIRCE2} spectra, it is possible to
 impose a Gaussian distributed beam energy, separately for each beam.
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 beams = e1, E1 => gaussian
 gaussian_spread_1 = 0.1\%
 gaussian_spread_2 = 0.2\%
 \end{Verbatim}
 \end{footnotesize}%$
 \end{quote}
 (Note that the \% sign means multiplication by 0.01, as it should.)  The
 spread values are defined as the $\sigma$ value of the Gaussian distribution,
 i.e., $2/3$ of the events are within $\pm 1\sigma$ for each beam,
 respectively.
 
 %%%%%%%%%%%%%%%%
 
 \subsection{Equivalent photon approximation}
 \label{sec:epa}
 
 The equivalent photon approximation (EPA) uses an on-shell approximation for
 the $e \to e\gamma$ collinear splitting to allow the simulation of
 photon-induced backgrounds in lepton collider physics. The original
 concept is that of the Weizs\"acker-Williams
 approximation~\cite{vonWeizsacker:1934sx,Williams:1934ad,Budnev:1974de}. This
 is a single-beam structure
 function that can be applied to both beams, or also to one beam
 only. Examples are:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 beams = e1, E1 => epa
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 or for a single beam:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 beams = e1, p => epa, pdf_builtin
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 The last process allows the reaction of (quasi-) on-shell photons with
 protons.
 
 In the following, we collect the parameters and flags that can be
 adjusted when using the EPA inside \whizard:
 
 \vspace{2mm}
 
 \centerline{\begin{tabular}{|l|l|l|}\hline
 Parameter & Default & Meaning \\\hline\hline
 \ttt{epa\_alpha} & \ttt{0}/intrinsic & value of $\alpha_{QED}$ for EPA
 \\\hline
 \ttt{epa\_x\_min} & \ttt{0.} & soft photon cutoff in $x$ (mandatory)
 \\\hline
 \ttt{epa\_q\_min} & \ttt{0.} & minimal $\gamma$ momentum transfer \\\hline
 \ttt{epa\_mass} & \ttt{0}/intrinsic & mass of the radiating fermion (mandatory)  \\\hline
 \ttt{epa\_q\_max} & \ttt{0}/$\sqrt{s}$ & upper cutoff for EPA \\\hline
 \ttt{?epa\_recoil} & \ttt{false} & flag to switch on recoil/$p_T$
 \\\hline
 \ttt{?epa\_keep\_energy} & \ttt{false} & recoil flag to conserve
 energy in splitting
 \\\hline
 \end{tabular}}\mbox{}
 
 The adjustable parameters are partially similar to the parameters in
 the QED initial-state radiation (ISR), cf. Sec.~\ref{sec:lepton_isr}:
 the parameter \ttt{epa\_alpha} sets the value of the electromagnetic
 coupling constant, $\alpha_{QED}$ used in the EPA structure
 function. If not set, this is taken from the value inside the active
 physics model. The same is true for the mass of the particle that
 radiates the photon of the hard interaction, which can be reset by the
 user with the variable \ttt{epa\_mass}. There are two dimensionful
 scale parameters, the minimal momentum transfer to the photon,
 \ttt{epa\_q\_min}, which must not be zero, and the upper momentum-transfer
 cutoff 
 for the EPA structure function, \ttt{epa\_q\_max}. The default for the
 latter value is the collider energy, $\sqrt{s}$, or the energy reduced
 by another structure function like e.g. beamstrahlung,
 $\sqrt{\hat{s}}$. Furthermore, there is a soft-photon regulator for
 the splitting function in $x$ space, \ttt{epa\_x\_min}, which also has
 to be explicitly set different from zero. Hence, a minimal viable
 scenario that will be accepted by \whizard\ looks like this:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 beams = e1, E1 => epa
 epa_q_min = 5 GeV
 epa_x_min = 0.01
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 
 Finally, like the ISR case in Sec.~\ref{sec:lepton_isr}, there is a
 flag to consider the recoil of the photon against the radiating
 electron by setting \ttt{?epa\_recoil} to \ttt{true} (default:
 \ttt{false}).
 
 Though in principle processes like $e^+ e^- \to e^+ e^- \gamma \gamma$
 where the two photons have been created almost collinearly and then
 initiate a hard process could be described by exact matrix elements
 and exact kinematics. However, the numerical stability in the very far
 collinear kinematics is rather challenging, such that the use of the
 EPA is very often an acceptable trade-off between quality of the
 description on the one hand and numerical stability and speed on the
 other hand.
 
 In the case, the EPA is set after a second structure function like a
 hadron collider PDF, there is a flavor summation over the quark
 constituents inside the proton, which are then the radiating fermions
 for the EPA. Here, the masses of all fermions have to be identical.
 
 More about the physics of the equivalent photon approximation can be
 found in Chap.~\ref{chap:hardint}.
 
 %%%%%%%%%%%%%%%
 
 \subsection{Effective $W$ approximation}
 \label{sec:ewa}
 
 An approach similar to the equivalent photon approximation (EPA)
 discussed in the previous section Sec.~\ref{sec:epa}, is the usage
 of a collinear splitting function for the radiation of massive
 electroweak vector bosons $W$/$Z$, the effective $W$ approximation
 (EWA). It has been developed for the
 description of high-energy weak vector-boson fusion and scattering
 processes at hadron colliders, particularly the Superconducting
 Super-Collider (SSC). This was at a time when the simulation of $2\to
 4$ processes war still very challenging and $2\to 6$ processes almost
 impossible, such that this approximation was the only viable solution
 for the simulation of processes like $pp \to jjVV$ and subsequent
 decays of the bosons $V \equiv W, Z$.
 
 Unlike the EPA, the EWA is much more involved as the structure
 functions do depend on the isospin of the radiating fermions, and are
 also different for transversal and longitudinal polarizations. Also, a
 truely collinear kinematics is never possible due to the finite $W$
 and $Z$ boson masses, which start becoming more and more negligible
 for energies larger than the nominal LHC energy of 14 TeV.
 
 Though in principle all processes for which the EWA might be
 applicable are technically feasible in \whizard\ to be generated also
 via full matrix elements, the EWA has been implemented in \whizard\
 for testing purposes, backwards compatibility and comparison with
 older simulations. Like the EPA, it is a single-beam structure
 function that can be applied to one or both beams. We only give an
 example for both beams here, this is for a 3 TeV CLIC collider:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 sqrts = 3 TeV
 beams = e1, E1 => ewa
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 And this is for LHC or a higher-energy follow-up collider (which also
 shows the concatenation of the single-beam structure functions,
 applied to both beams consecutively,
 cf. Sec.~\ref{sec:concatenation}:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 sqrts = 14 TeV
 beams = p, p => pdf_builtin => ewa
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 
 Again, we list all the options, parameters and flags that can be
 adapted for the EWA:
 
 \vspace{2mm}
 
 \centerline{\begin{tabular}{|l|l|l|}\hline
 Parameter & Default & Meaning \\\hline\hline
 \ttt{ewa\_x\_min} & \ttt{0.} & soft $W$/$Z$ cutoff in $x$ (mandatory)
 \\\hline
 \ttt{ewa\_mass} & \ttt{0}/intrinsic & mass of the radiating fermion  \\\hline
 \ttt{ewa\_pt\_max} & \ttt{0}/$\sqrt{\hat{s}}$ & upper cutoff for EWA \\\hline
 \ttt{?ewa\_recoil} & \ttt{false} & recoil switch
 \\\hline
 \ttt{?ewa\_keep\_energy} & \ttt{false} & energy conservation for
 recoil in splitting
 \\\hline
 \end{tabular}}\mbox{}
 
 First of all, all coupling constants are taken from the active physics
 model as they have to be consistent with electroweak gauge
 invariance. Like for EPA, there is a soft $x$ cutoff for the $f \to f
 V$ splitting, \ttt{ewa\_x\_min}, that has to be set different from
 zero by the user. Again, the mass of the radiating fermion can be set
 explicitly by the user; and, also again, the masses for the flavor sum
 of quarks after a PDF as radiators of the electroweak bosons have to
 be identical. Also for the EWA, there is an upper cutoff for the $p_T$
 of the electroweak boson, that can be set via
 \ttt{eta\_pt\_max}. Indeed, the transversal $W$/$Z$ structure function
 is logarithmically divergent in that variable. If it is not set by the
 user, it is estimated from $\sqrt{s}$ and the splitting kinematics.
 
 For the EWA, there is a flag to switch on a recoil for the
 electroweak boson against the radiating fermion,
 \ttt{?ewa\_recoil}. Note that this is an experimental feature that is
 not completely tested. In any case, the non-collinear kinematics
 violates 4-four momentum conservation, so there are two choices:
 either to conserve the energy (\ttt{?ewa\_keep\_energy = true}) or to
 conserve 3-momentum (\ttt{?ewa\_keep\_energy = false}). Momentum
 conservation for the kinematics is the default. This is due to the
 fact that for energy conservation, there will be a net total momentum
 in the event including the beam remnants (ISR/EPA/EWA radiated
 particles) that leeds to unexpected or unphysical features in the
 energy distributions of the beam remnants recoiling against the rest
 of the event.
 
 More details about the physics can be found in
 Chap.~\ref{chap:hardint}.
 
 
 %%%%%%%%%%%%%%%
 
 \subsection{Energy scans using structure functions}
 
 In \whizard, there is an implementation of a pair spectrum,
 \ttt{energy\_scan}, that allows to scan the energy dependence of a
 cross section without actually scanning over the collider
 energies. Instead, only a single integration at the upper end of the
 scan interval over the process with an additional pair spectrum
 structure function performed. The structure function is chosen
 in such a way, that the distribution of $x$ values of the energy scan
 pair spectrum translates in a plot over the energy of the final state
 in an energy scan from \ttt{0} to \ttt{sqrts} for the process under
 consideration.
 
 The simplest example is the $1/s$ fall-off with the $Z$ resonance in
 $e^+e^- \to \mu^+ \mu^-$, where the syntax is very easy:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 process eemm = e1, E1 => e2, E2
 sqrts = 500 GeV
 cuts = sqrts_hat > 50
 beams = e1, E1 => energy_scan
 integrate (eemm)
 \end{Verbatim}
 \end{footnotesize}
 \end{quote}
 The value of \ttt{sqrts = 500 GeV} gives the upper limit for the scan,
 while the cut effectively let the scan start at 50 GeV. There are no
 adjustable parameters for this structure function. How to plot the
 invariant mass distribution of the final-state muon pair to show the
 energy scan over the cross section, will be explained in
 Sec.~\ref{sec:analysis}.
 
 More details can be found in Chap.~\ref{chap:hardint}.
 
 %%%%%%%%%%%%%%%
 
 \subsection{Photon collider spectra}
 \label{sec:photoncoll}
 
 One option that has been discussed as an alternative possibility for a
 high-energy linear lepton collider is to convert the electron and
 positron beam via Compton backscattering off intense laser beams into
 photon
 beams~\cite{Ginzburg:1981vm,Telnov:1989sd,Telnov:1995hc}. Naturally,
 due to the production
 of the photon beams and the inherent electron spectrum, the photon
 beams have a characteristic spectrum. The simulation of such spectra
 is possible within \whizard\ by means of the subpackage \circetwo,
 which have been mentioned already in Sec.~\ref{sec:beamstrahlung}. It
 allows to give a much more elaborate description of a linear lepton
 collider environment than
 \circeone\ (which, however, is not in all cases necessary, as the ILC
 beamspectra for electron/positrons can be perfectly well described
 with \circeone).
 
 Here is a typical photon collider setup where we take a
 photon-initiated process:
 \begin{quote}
 \begin{footnotesize}
 \begin{Verbatim}
 process aaww = A, A => Wp, Wm
 
 beams = A, A => circe2
 $circe2_file = "teslagg_500_polavg.circe"
 $circe2_design = "TESLA/GG"
 ?circe2_polarized = false
 \end{Verbatim}
 \end{footnotesize}%$
 \end{quote}
 
 Here, the photons are the initial states initiating the hard
 scattering. The structure function is \ttt{circe2} which always is a
 pair spectrum. The list of available options are:
 
 \vspace{2mm}
 
 \centerline{\begin{tabular}{|l|l|l|}\hline
 Parameter & Default & Meaning \\\hline\hline
 \ttt{?circe2\_polarized} & \ttt{true} & spectrum respects polarization info
 \\\hline
 \ttt{\$circe2\_file} & -- & name of beam spectrum data file
 \\\hline
 \ttt{\$circe2\_design} & \ttt{"*"} & collider design
 \\\hline
 \end{tabular}}\mbox{}
 
 The only logical flag \ttt{?circe2\_polarized} let \whizard\ know
 whether it should keep polarization information in the beam spectra or
 average over polarizations. Naturally, because of the Compton
 backscattering generation of the photons, photon spectra are always
 polarized. The collider design can be specified by the string variable
 \ttt{\$circe2\_design}, where the default setting \ttt{"*"}
 corresponds to the default of \circetwo\ (which is the TESLA 500 GeV
 machine as discussed in the TESLA Technical Design
 Report~\cite{AguilarSaavedra:2001rg,Richard:2001qm}). Note that up to
 now there have not been any setups for a photon collider option for
 the modern linear collider concepts like ILC and CLIC. The string
 variable \ttt{\$circe2\_file} then allows to give the name of the file
 containing the actual beam spectrum; all files that ship with
 \whizard\ are stored in the directory \ttt{circe2/share/data}.
 
 More details about the subpackage \circetwo\ and the physics it
 covers, can be found in its own manual and the chapter
 Chap.~\ref{chap:hardint}.
 
 %%%%%%%%%%%%%%%
 
 \subsection{Concatenation of several structure functions}
 \label{sec:concatenation}
 
 As has been shown already in Sec.~\ref{sec:epa} and
 Sec.~\ref{sec:ewa}, it is possible within \whizard\ to concatenate
 more than one structure function, irrespective of the fact, whether
 the structure functions are single-beam structure functions or pair
 spectra. One important thing is whether there is a phase-space mapping
 for these structure functions. Also, there are some combinations which
 do not make sense from the physics point of view, for example using
 lepton-collider ISR for protons, and then afterwards switching on
 PDFs. Such combinations will be vetoed by \whizard, and you will find
 an error message like (cf. also Sec.~\ref{sec:errors}):
 \begin{interaction}
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR: Beam structure: [....] not supported
 ******************************************************************************
 ******************************************************************************
 \end{interaction}
 
 Common examples for the concatenation of structure functions are
 linear collider applications, where beamstrahlung (macroscopic
 electromagnetic beam-beam interactions) and electron QED initial-state
 radiation are both switched on:
 \begin{code}
 beams = e1, E1 => circe1 => isr
 \end{code}
 Another possibility is the simulation of photon-induced backgrounds at
 ILC or CLIC, using beamstrahlung and equivalent photon approximation
 (EPA):
 \begin{code}
 beams = e1, E1 => circe1 => epa
 \end{code}
 or with beam events from a data file:
 \begin{code}
 beams = e1, E1 => beam_events => isr
 \end{code}
 
 In hadron collider physics, parton distribution functions (PDFs) are
 basically always switched on, while afterwards the user could specify
 to use the effective $W$ approximation (EWA) to simulate high-energy
 vector boson scattering:
 \begin{code}
 sqrts = 100 TeV
 beams = p, p => pdf_builtin => ewa
 \end{code}
 Note that this last case involves a flavor sum over the five active
 quark (and anti-quark) species $u$, $d$, $c$, $s$, $b$ in the proton,
 all of which act as radiators for the electroweak vector bosons in the
 EWA.
 
 This would be an example with three structure functions:
 \begin{code}
 beams = e1, E1 => circe1 => isr => epa
 \end{code}
 
 %%%%%%%%%%%%%%%
 
 \section{Polarization}
 \label{sec:polarization}
 
 %%%%%
 
 \subsection{Initial state polarization}
 \label{sec:initialpolarization}
 
 \whizard\ supports polarizing the inital state fully or partially by
 assigning a nontrivial density matrix in helicity space.
 Initial state polarization requires a beam setup and is initialized by
 means of the \ttt{beams\_pol\_density} statement\footnote{Note that
   the syntax for the specification of beam polarization has changed
   from version v2.1 to v2.2 and is incompatible between the two
   release series. The old syntax \ttt{beam\_polarization} with its
   different polarization constructors has been discarded in favor of a
   unified syntax.}:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 beams_pol_density = @([<spin entries>]), @([<spin entries>])
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 The command \ttt{beams\_pol\_fraction} gives the degree of
 polarization of the two beams:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 beams_pol_fraction = <degree beam 1>, <degree beam 2>
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Both commands in the form written above apply to scattering processes,
 where the polarization of both beams must be specified. The
 \ttt{beams\_pol\_density} and \ttt{beams\_pol\_fraction} are possible
 with a single beam declaration if a decay process is considered, but
 only then.
 
 While the syntax for the command \ttt{beams\_pol\_fraction} is pretty
 obvious, the syntax for the actual specification of the beam
 polarization is more intricate. We start with the polarization
 fraction: for each beam there is a real number between zero
 (unpolarized) and one (complete polarization) that can be specified
 either as a floating point number like \ttt{0.4} or with a percentage:
 \ttt{40 \%}. Note that the actual arithmetics is sometimes
 counterintuitive: 80 \% left-handed electron polarization means that
 80 \% of the electron beam are polarized, 20 \% are unpolarized,
 i.e. 20 \% have half left- and half right-handed polarization
 each. Hence, 90 \% of the electron beam is left-handed, 10 \% is
 right-handed.
 
 How does the specification of the polarization work? If there are no
 entries at all in the polarization constructor, \ttt{@()}, the beam is
 unpolarized, and the spin density matrix is proportional to the
 unit/identity matrix. Placing entries into the \ttt{@()} constructor
 follows the concept of sparse matrices, i.e. the entries that have
 been specified will be present, while the rest remains zero. Single
 numbers do specify entries for that particular helicity on the main
 diagonal of the spin density matrix, e.g. for an electron \ttt{@(-1)}
 means (100\%) left-handed polarization. Different entries are
 separated by commas: \ttt{@(1,-1)} sets the two diagonal entries at
 positions $(1,1)$ and $(-1,-1)$ in the density matrix both equal to
 one. Two remarks are in order
 already here. First, note that you do not have to worry about the
 correct normalization of the spin density matrix, \whizard\ is taking
 care of this automatically. Second, in the screen output for the beam
 data, only those entries of the spin density matrix that have been
 specified by the user, will be displayed. If a
 \ttt{beams\_pol\_fraction} statement appears, other components will be
 non-zero, but might not be shown. E.g. ILC-like, 80 \% polarization of
 the electrons, 30 \% positron polarization will be specified like this
 for left-handed electrons and right-handed positrons:
 \begin{code}
 beams = e1, E1
 beams_pol_density = @(-1), @(+1)
 beams_pol_fraction = 80%, 30%
 \end{code}
 The screen output will be like this:
 \begin{code}
 | ------------------------------------------------------------------------
 | Beam structure: e-, e+
 |   polarization (beam 1):
 |     @(-1: -1: ( 1.000000000000E+00, 0.000000000000E+00))
 |   polarization (beam 2):
 |     @(+1: +1: ( 1.000000000000E+00, 0.000000000000E+00))
 |   polarization degree = 0.8000000, 0.3000000
 | Beam data (collision):
 |   e-   (mass = 0.0000000E+00 GeV)  polarized
 |   e+   (mass = 0.0000000E+00 GeV)  polarized
 \end{code}
 But because of the fraction of unpolarized electrons and positrons,
 the spin density matrices for electrons and positrons are:
 \[
 \rho(e^-) = \diag \left ( 0.10, 0.90 \right) \qquad
 \rho(e^+) = \diag \left ( 0.65, 0.35 \right) \quad ,
 \]
 respectively. So, in general, only the entries due to the polarized
 fraction will be displayed on screen. We will come back to more
 examples below.
 
 Again, the setting of a single entry, e.g. \ttt{@($\pm m$)}, which
 always sets the diagonal component $(\pm m, \pm m)$ of the spin
 density matrix equal to one. Here $m$ can have the following values
 for the different spins (in parentheses are entries that exist only
 for massive particles):
 
 \vspace{1mm}
 
 \begin{center}
 \begin{tabular}{|l|l|l|}\hline
   Spin $j$ & Particle type & possible $m$ values \\\hline
   0   & Scalar boson           & 0 \\
   1/2 & Spinor                 & +1, -1 \\
   1   & (Massive) Vector boson & +1, (0), -1 \\
   3/2 & (Massive) Vectorspinor & +2, (+1), (-1), -2 \\
   2   & (Massive) Tensor       & +2, (+1), (0), (-1), -2
   \\\hline
 \end{tabular}
 \end{center}
 
 \vspace{1mm}
 
 Off-diagonal entries that are equal to one (up to the normalization)
 of the spin-density matrix can be specified simply by the position,
 namely: \ttt{@($m$:$m'$, $m''$)}. This would result in a spin density
 matrix with diagonal entry $1$ for the position $(m'', m'')$, and an entry
 of $1$ for the off-diagonal position $(m,m')$.
 
 Furthermore, entries in the density matrix different from $1$ with a
 numerical value \ttt{{\em <val>}} can be
 specified, separated by another colon: \ttt{@($m$:$m'$:{\em
 <val>})}. Here, it does not matter whether $m$ and $m'$ are different
 or not. For $m = m'$ also diagonal spin density matrix entries
 different from one can be specified. Note that because spin density
 matrices have to be Hermitian, only the entry $(m,m')$ has to be set,
 while the complex conjugate entry at the transposed position $(m',m)$
 is set automatically by \whizard.
 
 We will give some general density
 matrices now, and after that a few more definite examples. In the
 general setups below, we always give the expression for the spin
 density matrix only for one single beam.
 %
 {
 
 \newcommand{\cssparse}[4]{%
 \begin{pmatrix}
   #1     & 0      & \cdots & \cdots & #3     \\
   0      & 0      & \ddots &        & 0      \\
   \vdots & \ddots & \ddots & \ddots & \vdots \\
   0      &        & \ddots & 0      & 0      \\
   #4     & \cdots & \cdots & 0      & #2
 \end{pmatrix}%
 }
 %
 
 \begin{itemize}
 \item {\bf Unpolarized:}
   \begin{center}
     \begin{footnotesize}
     \ttt{beams\_pol\_density = @()}
     \end{footnotesize}
   \end{center}
 % \newline
 This has the same effect as not specifying any
 polarization at all and is the only constructor available for scalars and
 fermions declared as left- or right-handed (like the neutrino). Density matrix:
 \[ \rho = \frac{1}{|m|}\mathbb{I} \]
 ($|m|$: particle multiplicity which is 2 for massless, $2j + 1$ for massive particles).
 %
 \item {\bf Circular polarization:}
   \begin{center}
     \begin{footnotesize}
     \ttt{beams\_pol\_density = @($\pm j$) \qquad beams\_pol\_fraction
       = $f$}
     \end{footnotesize}
   \end{center}
 A fraction $f$ (parameter range $f \in \left[0\;;\;1\right]$) of
 the particles are in the maximum / minimum helicity eigenstate $\pm
 j$, the remainder is unpolarized. For spin $\frac{1}{2}$ and massless
 particles of spin $>0$, only the maximal / minimal entries of the
 density matrix are populated, and the density matrix looks like this:
 \[ \rho = \diag\left(\frac{1\pm f}{2}\;,\;0\;,\;\dots\;,\;0\;,
 \frac{1\mp f}{2}\right) \]
 %
 \item {\bf Longitudinal polarization (massive):}
   \begin{center}
     \begin{footnotesize}
     \ttt{beams\_pol\_density = @(0) \qquad beams\_pol\_fraction = $f$}
     \end{footnotesize}
   \end{center}
 We consider massive particles with maximal spin component $j$, a
 fraction $f$ of which having longitudinal polarization, the remainder
 is unpolarized. Longitudinal polarization is (obviously) only
 available for massive bosons of spin $>0$. Again, the parameter range
 for the fraction is: $f \in \left[0\;;\;1\right]$. The density matrix
 has the form:
 \[ \rho = \diag\left(\frac{1-f}{|m|}\;,\;\dots\;,\;\frac{1-f}{|m|}\;,\;
 \frac{1+f \left(|m| - 1\right)}{|m|}\;,\;\frac{1-f}{|m|}\;,
 \;\dots\;,\;\frac{1-f}{|m|}\right)
 \]
 ($|m| = 2j+1 $: particle multiplicity)
 %
 \item {\bf Transverse polarization (along an axis):}
   \begin{center}
     \begin{footnotesize}
     \ttt{beams\_pol\_density = @(j, -j, j:-j:exp(-I*phi)) \qquad
       beams\_pol\_fraction = $f$}
     \end{footnotesize}
   \end{center}
 This so called transverse polarization is a polarization along an
 arbitrary direction in the $x-y$ plane, with $\phi=0$ being the positive
 $x$ direction and $\phi=90^\circ$ the positive $y$ direction. Note that
 the value of \ttt{phi} has either to be set inside the beam
 polarization expression explicitly or by a statement \ttt{real phi =
   {\em val} degree} before. A fraction $f$ of the particles are
 polarized, the remainder is unpolarized. Note that, although
 this yields a valid density matrix for all particles with multiplicity
 $>1$ (in which the only the highest and lowest helicity states are
 populated), it is meaningful only for spin $\frac{1}{2}$ particles and
 massless bosons of spin $>0$. The range of the parameters are:
 $f \in \left[0\;;\;1\right]$ and $\phi \in \mathbb{R}$. This yields a
 density matrix:
 \[ \rho =
 \cssparse{1}{1}
    {\frac{f}{2}\,e^{-i\phi}} {\frac{f}{2}\,e^{i\phi}} \]
 (for antiparticles, the matrix is conjugated).
 %
 \item {\bf Polarization along arbitrary axis $\left(\theta, \phi\right)$:}
   \begin{center}
     \begin{footnotesize}
     \ttt{beams\_pol\_density = @(j:j:1-cos(theta),
       j:-j:sin(theta)*exp(-I*phi), -j:-j:1+cos(theta))} \qquad\quad\qquad
     \ttt{beams\_pol\_fraction = $f$}
     \end{footnotesize}
   \end{center}
 This example describes polarization along an arbitrary axis in polar
 coordinates (polar axis in positive $z$ direction, polar angle
 $\theta$, azimuthal angle $\phi$). A fraction $f$ of the particles are
 polarized, the remainder is unpolarized. Note that, although axis
 polarization defines a valid density matrix for all particles with
 multiplicity $>1$, it is meaningful only for particles with spin
 $\frac{1}{2}$. Valid ranges for the parameters are $f \in
 \left[0\;;\;1\right]$, $\theta \in \mathbb{R}$, $\phi \in
 \mathbb{R}$. The density matrix then has the form:
 \[ \rho = \frac{1}{2}\cdot
 \cssparse{1 - f\cos\theta}{1 + f\cos\theta}
    {f\sin\theta\, e^{-i\phi}}{f\sin\theta\, e^{i\phi}}
 \]
 %
 \item {\bf Diagonal density matrix:}
   \begin{center}
     \begin{footnotesize}
     \ttt{beams\_pol\_density = @(j:j:$h_j$, j-1:j-1:$h_{j-1}$,
       $\ldots$, -j:-j:$h_{-j}$)}
     \end{footnotesize}
   \end{center}
 This defines an arbitrary diagonal density matrix with entries
 $\rho_{j,j}\,,\,\dots\,,\,\rho_{-j,-j}$.
 %
 \item {\bf Arbitrary density matrix:}
   \begin{center}
     \begin{footnotesize}
     \ttt{beams\_pol\_density = @($\{m:m':x_{m,m'}\}$)}:
     \end{footnotesize}
   \end{center}
 Here, \ttt{$\{m:m':x_{m,m'}\}$} denotes a selection of entries at
 various positions somewhere in the spin density matrix. \whizard\
 will check whether this is a valid spin density matrix, but it does
 e.g. not have to correspond to a pure state.
 %
 \end{itemize}
 }
 %
 
 The beam polarization statements can be used both globally directly
 with the \ttt{beams} specification, or locally inside the
 \ttt{integrate} or \ttt{simulate} command. Some more specific examples
 are in order to show how initial state polarization works:
 %
 \begin{itemize}
 \item
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 beams = A, A
 beams_pol_density = @(+1),  @(1, -1, 1:-1:-I)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 This declares the initial state to be composed of two incoming
 photons, where the first photon is right-handed, and the second photon
 has transverse polarization in $y$ direction.
 %
 \item
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 beams = A, A
 beams_pol_density = @(+1),  @(1, -1, 1:-1:-1)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Same as before, but this time the second photon has transverse
 polarization in $x$ direction.
 
 %
 \item
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 beams = "W+"
 beams_pol\_density = @(0)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 This example sets up the decay of a longitudinal vector boson.
 %
 \item
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 beams = E1, e1
 scan int hel_ep = (-1, 1) {
    scan int hel_em = (-1, 1) {
       beams_pol_density = @(hel_ep), @(hel_em)
       integrate (eeww)
    }
 }
 integrate (eeww)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 This example loops over the different positron and electron helicity
 combinations and calculates the respective integrals. The
 \ttt{beams\_pol\_density} statement is local to the scan loop(s) and,
 therefore, the last \ttt{integrate} calculates the unpolarized
 integral.
 \end{itemize}
 %
 
 Although beam polarization should be straightforward to use, some pitfalls exist
 for the unwary:
 \begin{itemize}
 \item Once \ttt{beams\_pol\_density} is set globally, it persists and
 is applied every time \ttt{beams} is executed (unless it is reset). In
 particular, this means that code like
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 process wwaa = Wp, Wm => A, A
 process zee = Z => e1, E1
 
 sqrts = 200 GeV
 beams_pol_density = @(1, -1, 1:-1:-1), @()
 beams = Wp, Wm
 integrate (wwaa)
 beams = Z
 integrate (zee)
 beams_pol_density = @(0)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 will throw an error, because \whizard\ complains that the spin density
 matrix has the wrong dimensionality for the second (the decay) process.
 This kind of trap can be avoided be using \ttt{beams\_pol\_density}
 only locally in \ttt{integrate} or \ttt{simulate} statements.
 %
 \item On-the-fly integrations executed by \ttt{simulate}
 use the beam
 setup found at the point of execution. This implies that any polarization
 settings you have previously done affect the result of the integration.
 %
 \item The \ttt{unstable} command also requires integrals of the selected decay
   processes, and will compute them on-the-fly if they are unavailable.  Here,
   a polarized integral is not meaningful at all.  Therefore, this command
   ignores the current \ttt{beam} setting and issues a warning if a previous
   polarized integral is available; this will be discarded.
 \end{itemize}
 
 
 \subsection{Final state polarization}
 
 Final state polarization is available in \whizard\ in the sense that the
 polarization of real final state particles can be retained when generating
 simulated
 events. In order for the polarization of a particle to be retained, it must be
 declared as polarized via the \ttt{polarized} statement
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 polarized particle [, particle, ...]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 The effect of \ttt{polarized} can be reversed with the \ttt{unpolarized}
 statement which has the same syntax. For example,
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 polarized "W+", "W-", Z
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 will cause the polarization of all final state $W$ and $Z$ bosons to be
 retained, while
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 unpolarized "W+", "W-", Z
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 will reverse the effect and cause the polarization to be summed over again. Note
 that \ttt{polarized} and \ttt{unpolarized} are global statements which cannot be
 used locally as command arguments and if you use them e.g. in a loop, the
 effects will persist beyond the loop body. Also, a particle cannot be
 \ttt{polarized} and \ttt{unstable} at the same time (this restriction
 might be loosened in future versions of \whizard).
 
 After toggling the polarization flag, the generation of polarized events can be
 requested by using the \ttt{?polarized\_events} option of the \ttt{simulate}
 command, e.g.
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 simulate (eeww) { ?polarized_events = true }
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 When \ttt{simulate} is run in this mode, helicity information for final state
 particles that have been toggled as \ttt{polarized} is written to the event
 file(s) (provided that polarization is supported by the selected event file
 format(s) ) and can also be accessed in the analysis by means of the \ttt{Hel}
 observable. For example, an analysis definition like
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 analysis =
   if (all Hel == -1 ["W+"] and all Hel == -1 ["W-"] ) then
     record cta_nn (eval cos (Theta) ["W+"]) endif;
   if (all Hel == -1 ["W+"] and all Hel ==  0 ["W-"] )
     then record cta_nl (eval cos (Theta) ["W+"]) endif
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 can be used to histogram the angular distribution for the production of
 polarized $W$ pairs (obviously, the example would have to be extended
 to cover all possible helicity combinations). Note, however, that
 helicity information is not available in the integration step;
 therefore, it is not possible to use \ttt{Hel} as a cut observable.
 
 While final state polarization is straightforward to use, there is a caveat when
 used in combination with flavor products. If a particle in a flavor product is
 defined as \ttt{polarized}, then all particles ``originating'' from the product will
 act as if they had been declared as \ttt{polarized} --- their polarization will
 be recorded in the generated events. E.g., the example
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 process test = u:d, ubar:dbar => d:u, dbar:ubar, u, ubar
 
 ! insert compilation, cuts and integration here
 
 polarized d, dbar
 simulate (test) {?polarized_events = true}
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 will generate events including helicity information for all final state $d$ and
 $\overline{d}$ quarks, but only for part of the final state $u$ and $\overline{u}$
 quarks. In this case, if you had wanted to keep the helicity information also
 for all $u$ and $\overline{u}$, you would have had to explicitely include them
 into the \ttt{polarized} statement.
 
 
 \section{Cross sections}
 
 Integrating matrix elements over phase space is the core of \whizard's
 activities.  For any process where we want the cross section, distributions,
 or event samples, the cross section has to be determined first.  This is done
 by a doubly adaptive multi-channel Monte-Carlo integration.  The integration,
 in turn, requires a \emph{phase-space setup}, i.e., a collection of
 phase-space \emph{channels}, which are mappings of the unit hypercube onto the
 complete space of multi-particle kinematics.  This phase-space information is
 encoded in the file \emph{xxx}\ttt{.phs}, where \emph{xxx} is the process tag.
 \whizard\ generates the phase-space file on the fly and can reuse it in later
 integrations.
 
 For each phase-space channel, the unit hypercube is binned in each dimension.
 The bin boundaries are allowed to move during a sequence of iterations, each
 with a fixed number of sampled phase-space points, so they adapt to the actual
 phase-space density as far as possible.  In addition to this \emph{intrinsic}
 adaptation, the relative channel weights are also allowed to vary.
 
 All these steps are done automatically when the \ttt{integrate} command is
 executed.  At the end of the iterative adaptation procedure, the program has
 obtained an estimate for the integral of the matrix element over phase space,
 together with an error estimate, and a set of integration \emph{grids} which
 contains all information on channel weights and bin boundaries.  This
 information is stored in a file \emph{xxx}\ttt{.vg}, where \emph{xxx} is the
 process tag, and is used for event generation by the \ttt{simulate}
 command.
 
 
 \subsection{Integration}
 \label{sec:integrate}
 
 Since everything can be handled automatically using default parameters, it
 often suffices to write the command
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   integrate (proc1)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 for integrating the process with name tag \ttt{proc1}, and similarly
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   integrate (proc1, proc2, proc3)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 for integrating several processes consecutively.  Options to the integrate
 command are specified, if not globally, by a local option string
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   integrate (proc1, proc2, proc3) { mH = 200 GeV }
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 (It is possible to place a \ttt{beams} statement inside the option string, if
 desired.)
 
 If the process is configured but not compiled, compilation will be done
 automatically.   If it is not available at all, integration will fail.
 
 The integration method can be specified by the string variable
 \begin{quote}
 \begin{footnotesize}
   \ttt{\$integration\_method = "{\em <method>}"}
 \end{footnotesize}
 \end{quote} %$
 The default method is called \ttt{"vamp"} and uses the \vamp\
 algorithm and code. (At the moment, there is only a single simplistic
 alternative, using the midpoint rule or rectangle method for
 integration, \ttt{"midpoint"}. This is mainly for testing purposes. In
 future versions of \whizard, more methods like e.g. Gauss integration
 will be made available). \vamp, however, is clearly the main
 integration method. It is done in several \emph{passes} (usually two),
 and each pass consists of several \emph{iterations}.  An iteration
 consists of a definite number of \emph{calls} to the matrix-element
 function.
 
 For each iteration, \whizard\ computes an estimate of the integral and an
 estimate of the error, based on the binned sums of matrix element values and
 squares.  It also computes an estimate of the rejection efficiency for
 generating unweighted events, i.e., the ratio of the average sampling function
 value over the maximum value of this function.
 
 After each iteration, both the integration grids (the binnings) and the
 relative weights of the integration channels can be adapted to
 minimize the variance estimate of the integral.  After each pass of several
 iterations, \whizard\ computes an average of the iterations within the pass,
 the corresponding error estimate, and a $\chi^2$ value.  The integral, error,
 efficiency and $\chi^2$ value computed for the most recent integration pass,
 together with the most recent integration grid, are used for any subsequent
 calculation that involves this process, in particular for event generation.
 
 In the default setup, during the first pass(es) both grid binnings and channel
 weights are adapted.  In the final (usually second) pass, only binnings are
 further adapted.  Roughly speaking, the final pass is the actual calculation,
 while the previous pass(es) are used for ``warming up'' the integration grids,
 without using the numerical results. Below, in the section about the
 specification of the iterations, Sec.~\ref{sec:iterations}, we will
 explain how it is possible to change the behavior of adapting grids
 and weights.
 
 Here is an example of the integration output, which illustrates these
 properties.  The \sindarin\ script describes the process $e^+e^-\to q\bar q
 q\bar q$ with $q$ being any light quark, i.e., $W^+W^-$ and $ZZ$ production
 and hadronic decay together will any irreducible background.  We cut on $p_T$
 and energy of jets, and on the invariant mass of jet pairs.  Here is the
 script:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 alias q = d:u:s:c
 alias Q = D:U:S:C
 process proc_4f = e1, E1 => q, Q, q, Q
 
 ms = 0  mc = 0
 sqrts = 500 GeV
 cuts = all (Pt > 10 GeV and E > 10 GeV) [q:Q]
    and all M > 10 GeV [q:Q, q:Q]
 
 integrate (proc_4f)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 After the run is finished, the integration output looks like
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 | Process library 'default_lib': loading
 | Process library 'default_lib': ... success.
 | Integrate: compilation done
 | RNG: Initializing TAO random-number generator
 | RNG: Setting seed for random-number generator to 12511
 | Initializing integration for process proc_4f:
 | ------------------------------------------------------------------------
 | Process [scattering]: 'proc_4f'
 |   Library name  = 'default_lib'
 |   Process index = 1
 |   Process components:
 |     1: 'proc_4f_i1':   e-, e+ => d:u:s:c, dbar:ubar:sbar:cbar,
 |                                  d:u:s:c, dbar:ubar:sbar:cbar [omega]
 | ------------------------------------------------------------------------
 | Beam structure: [any particles]
 | Beam data (collision):
 |   e-  (mass = 5.1099700E-04 GeV)
 |   e+  (mass = 5.1099700E-04 GeV)
 |   sqrts = 5.000000000000E+02 GeV
 | Phase space: generating configuration ...
 | Phase space: ... success.
 | Phase space: writing configuration file 'proc_4f_i1.phs'
 | Phase space: 123 channels, 8 dimensions
 | Phase space: found 123 channels, collected in 15 groves.
 | Phase space: Using 195 equivalences between channels.
 | Phase space: wood
 | Applying user-defined cuts.
 | OpenMP: Using 8 threads
 | Starting integration for process 'proc_4f'
 | Integrate: iterations not specified, using default
 | Integrate: iterations = 10:10000:"gw", 5:20000:""
 | Integrator: 15 chains, 123 channels, 8 dimensions
 | Integrator: Using VAMP channel equivalences
 | Integrator: 10000 initial calls, 20 bins, stratified = T
 | Integrator: VAMP
 |=============================================================================|
 | It      Calls  Integral[fb]  Error[fb]   Err[%]    Acc  Eff[%]   Chi2 N[It] |
 |=============================================================================|
    1       9963  2.3797857E+03  3.37E+02   14.15   14.13*   4.02
    2       9887  2.8307603E+03  9.58E+01    3.39    3.37*   4.31
    3       9815  3.0132091E+03  5.10E+01    1.69    1.68*   8.37
    4       9754  2.9314937E+03  3.64E+01    1.24    1.23*  10.65
    5       9704  2.9088284E+03  3.40E+01    1.17    1.15*  12.99
    6       9639  2.9725788E+03  3.53E+01    1.19    1.17   15.34
    7       9583  2.9812484E+03  3.10E+01    1.04    1.02*  17.97
    8       9521  2.9295139E+03  2.88E+01    0.98    0.96*  22.27
    9       9435  2.9749262E+03  2.94E+01    0.99    0.96   20.25
   10       9376  2.9563369E+03  3.01E+01    1.02    0.99   21.10
 |-----------------------------------------------------------------------------|
   10      96677  2.9525019E+03  1.16E+01    0.39    1.22   21.10    1.15  10
 |-----------------------------------------------------------------------------|
   11      19945  2.9599072E+03  2.13E+01    0.72    1.02   15.03
   12      19945  2.9367733E+03  1.99E+01    0.68    0.96*  12.68
   13      19945  2.9487747E+03  2.03E+01    0.69    0.97   11.63
   14      19945  2.9777794E+03  2.03E+01    0.68    0.96*  11.19
   15      19945  2.9246612E+03  1.95E+01    0.67    0.94*  10.34
 |-----------------------------------------------------------------------------|
   15      99725  2.9488622E+03  9.04E+00    0.31    0.97   10.34    1.05   5
 |=============================================================================|
 | Time estimate for generating 10000 events: 0d:00h:00m:51s
 | Creating integration history display proc_4f-history.ps and proc_4f-history.pdf
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Each row shows the index of a single iteration, the number of matrix element
 calls for that iteration, and the integral and error estimate.  Note
 that the number of calls displayed are the real calls to the matrix
 elements after all cuts and possible rejections. The error
 should be viewed as the $1\sigma$ uncertainty, computed on a statistical
 \begin{figure}
   \centering
   \includegraphics[width=.56\textwidth]{proc_4f-history}
   \caption{\label{fig:inthistory} Graphical output of the convergence
     of the adaptation during the integration of a \whizard\ process.}
 \end{figure}
 basis.  The next two columns display the error in percent, and the
 \emph{accuracy} which is the same error normalized by $\sqrt{n_{\rm calls}}$.
 The accuracy value has the property that it is independent of $n_{\rm calls}$,
 it describes the quality of adaptation of the current grids.  Good-quality
 grids have a number of order one, the smaller the better.  The next column is
 the estimate for the rejection efficiency in percent.  Here, the value should
 be as high as possible, with $100\,\%$ being the possible maximum.
 
 In the example, the grids are adapted over ten iterations, after which the
 accuracy and efficiency have saturated at about $1.0$ and $10\,\%$,
 respectively.  The asterisk in the accuracy column marks those iterations
 where an improvement over the previous iteration is seen.  The average over
 these iterations exhibits an accuracy of $1.22$, corresponding to $0.39\,\%$
 error, and a $\chi^2$ value of $1.15$, which is just right:
 apparently, the phase-space for this process and set of cuts is
 well-behaved.  The subsequent five iterations are used for obtaining
 the final integral, which has an accuracy below one (error $0.3\,\%$),
 while the efficiency settles at about
 $10\,\%$.  In this example, the final $\chi^2$ value happens to be quite
 small, i.e., the individual results are closer together than the error
 estimates would suggest.  One should nevertheless not scale down the error,
 but rather scale it up if the $\chi^2$ result happens to be much larger than
 unity: this often indicates sub-optimally adapted grids, which insufficiently
 map some corner of phase space.
 
 One should note that all values are subject to statistical fluctuations, since
 the number of calls within each iterations is finite.  Typically, fluctuations
 in the efficiency estimate are considerably larger than fluctuations in the
 error/accuracy estimate.  Two subsequent runs of the same script should yield
 statistically independent results which may differ in all quantities, within
 the error estimates, since the seed of the random-number generator will differ
 by default.
 
 It is possible to get exactly reproducible results by setting the
 random-number seed explicitly, e.g.,
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   seed = 12345
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 at any point in the \sindarin\ script.  \ttt{seed} is a predefined intrinsic
 variable.  The value can be any 32bit integer.  Two runs with different seeds
 can be safely taken as statistically independent. In the example
 above, no seed has been set, and the seed has therefore been
 determined internally by \whizard\ from the system clock.
 
 The concluding line with the time estimate applies to a subsequent simulation
 step with unweighted events, which is not actually requested in the current
 example.  It is based on the timing and efficiency estimate of the most recent
 iteration.
 
 As a default, a graphical output of the integration history will be
 produced (if both \LaTeX\ and \metapost\ have been available during
 configuration). Fig.~\ref{fig:inthistory} shows how this looks like,
 and demonstrates how a proper convergence of the integral during the
 adaptation looks like. The generation of these graphical history files
 can be switched off using the command \ttt{?vis\_history = false}.
 
 %%%%%
 
 \subsection{Integration run IDs}
 
 A single \sindarin\ script may contain multiple calls to the
 \ttt{integrate} command with different parameters.  By default,
 files generated for the same process in a subsequent integration will
 overwrite the previous ones.  This is undesirable when the script is
 re-run: all results that have been overwritten have to be recreated.
 
 To avoid this, the user may identify a specific run by a string-valued
 ID, e.g.
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   integrate (foo) { $run_id = "first" }
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 This ID will become part of the file name for all files that are
 created specifically for this run.  Often it is useful to create a run
 ID from a numerical value using \ttt{sprintf}, e.g., in this scan:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   scan real mh = (100 => 200 /+ 10) {
     $run_id = sprintf "%e" (mh)
     integrate (h_production)
   }
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 
 With unique run IDs, a subsequent run of the same \sindarin\ script
 will be able to reuse all previous results, even if there is more than
 a single integration per process.
 
 
 
 
 \subsection{Controlling iterations}
 \label{sec:iterations}
 
 \whizard\ has some predefined numbers of iterations and calls for the first
 and second integration pass, respectively, which depend on the number of
 initial and final-state particles.  They are guesses for values that yield
 good-quality grids and error values in standard situations, where no
 exceptionally strong peaks or loose cuts are present in the integrand.
 Actually, the large number of warmup iterations in the previous example
 indicates some safety margin in that respect.
 
 It is possible, and often advisable, to adjust the iteration and call numbers
 to the particular situation.  One may reduce the default numbers to short-cut
 the integration, if either less accuracy is needed, or CPU time is to be
 saved.  Otherwise, if convergence is bad, the number of iterations or calls
 might be increased.
 
 To set iterations manually, there is the \ttt{iterations} command:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   iterations = 5:50000, 3:100000
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 This is a comma-separated list.  Each pair of values corresponds to an
 integration pass.  The value before the colon is the number of iterations for
 this pass, the other number is the number of calls per iteration.
 
 While the default number of passes is two (one for warmup, one for the final
 result), you may specify a single pass
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   iterations = 5:100000
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 where the relative channel weights will \emph{not} be adjusted (because this
 is the final pass).  This is appropriate for well-behaved integrands where
 weight adaptation is not necessary.
 
 You can also define more than two passes.  That might be useful when reusing a
 previous grid file with insufficient quality: specify the previous passes
 as-is, so the previous results will be read in, and then a new pass for
 further adaptation.
 
 In the final pass, the default behavior is to not adapt grids and
 weights anymore. Otherwise, different iterations would be correlated,
 and a final reliable error estimate would not be possible. For all but
 the final passes, the user can decide whether to adapt grids and
 weights by attaching a string specifier to the number of iterations:
 \ttt{"g"} does adapt grids, but not weights, \ttt{"w"} the other way
 round. \ttt{"gw"} or \ttt{"wg"} does adapt both. By the setting
 \ttt{""}, all adaptations are switched off. An example looks like
 this:
 \begin{code}
   iterations = 2:10000:"gw", 3:5000
 \end{code}
 
 Since it is often not known beforehand how many iterations the grid
 adaptation will need, it is generally a good idea to give the first
 pass a large number of iterations.  However, in many cases these turn
 out to be not necessary.  To shortcut iterations, you can set any of
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 accuracy_goal
 error_goal
 relative_error_goal
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 to a positive value.  If this is done, \whizard\ will skip warmup
 iterations once all of the specified goals are reached by the current
 iteration.  The final iterations (without weight adaptation) are
 always performed.
 
 
 \subsection{Phase space}
 
 Before \ttt{integrate} can start its work, it must have a phase-space
 configuration for the process at hand.  The method for the phase-space
 parameterization is determined by the string variable
 \ttt{\$phs\_method}. At the moment there are only two options,
 \ttt{"single"}, for testing purposes, that is mainly used internally,
 and \whizard's traditional method, \ttt{"wood"}. This parameterization
 is particularly adapted and fine-tuned for electroweak processes and
 might not be the ideal for for pure jet cross sections. In future
 versions of \whizard, more options for phase-space parameterizations
 will be made available, e.g. the \ttt{RAMBO} algorithm and its massive
 cousin, and phase-space parameterizations that take care of the
 dipole-like emission structure in collinear QCD (or QED) splittings.
 For the standard method, the phase-space parameterization is laid out
 in an ASCII file \ttt{\textit{<process-name>\_}i\textit{<comp>}.phs}.
 Here, \ttt{{\em <process-name>}} is the process name chosen by the
 user while \ttt{{\em <comp>}} is the number of the process component
 of the corresponding process. This immediately shows that different
 components of processes are getting different phase space setups. This
 is necessary for inclusive processes, e.g. the sum of $pp \to Z + nj$
 and $pp \to W + nj$, or in future versions of \whizard\ for NLO
 processes, where one component is the interference between the virtual
 and the Born matrix element, and another one is the subtraction terms.
 Normally, you do not have to deal with this file, since \whizard\ will
 generate one automatically if it does not find one. (\whizard\ is
 careful to check for consistency of process definition and parameters
 before using an existing file.)
 
 Experts might find it useful to generate a phase-space file and inspect and/or
 modify it before proceeding further.  To this end, there is the parameter
 \verb|?phs_only|.  If you set this \ttt{true}, \whizard\ skips the actual
 integration after the phase-space file has been generated.  There is also a
 parameter \verb|?vis_channels| which can be set independently; if this is
 \ttt{true}, \whizard\ will generate a graphical visualization of the
 phase-space parameterizations encoded in the phase-space file. This
 file has to be taken with a grain of salt because phase space channels
 are represented by sample Feynman diagrams for the corresponding
 channel. This does however {\em not} mean that in the matrix element
 other Feynman diagrams are missing (the default matrix element method,
 \oMega, is not using Feynman-diagrammatic amplitudes at all).
 
 Things might go wrong with the default phase-space generation, or manual
 intervention might be necessary to improve later performance.  There are a few
 parameters that control the algorithm of phase-space generation.  To
 understand their meaning, you should realize that phase-space
 parameterizations are modeled after (dominant) Feynman graphs for the current
 process.
 
 \subsubsection{The main phase space setup {\em wood}}
 
 For the main phase-space parameterization of \whizard, which is called
 \ttt{"wood"}, there are many different parameters and flags that allow
 to tune and customize the phase-space setup for every certain process:
 
 The parameter \verb|phs_off_shell| controls the number of off-shell lines in
 those graphs, not counting $s$-channel resonances and logarithmically enhanced
 $s$- and $t$-channel lines.  The default value is $2$.  Setting it to zero
 will drop everything that is not resonant or logarithmically enhanced.
 Increasing it will include more subdominant graphs.  (\whizard\ increases the
 value automatically if the default value does not work.)
 
 There is a similar parameter \verb|phs_t_channel| which controls
 multiperipheral graphs in the parameterizations.  The default value is $6$, so
 graphs with up to $6$ $t/u$-channel lines are considered.  In particular
 cases, such as $e^+e^-\to n\gamma$, all graphs are multiperipheral, and for
 $n>7$ \whizard\ would find no parameterizations in the default setup.
 Increasing the value of \verb|phs_t_channel| solves this problem.  (This is
 presently not done automatically.)
 
 There are two numerical parameters that describe whether particles are treated
 like massless particles in particular situations.  The value of
 \verb|phs_threshold_s| has the default value $50\;\GeV$.  Hence, $W$ and $Z$
 are considered massive, while $b$ quarks are considered massless.  This
 categorization is used for deciding whether radiation of $b$ quarks can lead
 to (nearly) singular behavior, i.e., logarithmic enhancement, in the infrared
 and collinear regions.  If yes, logarithmic mappings are applied to phase
 space.  Analogously, \verb|phs_threshold_t| decides about potential
 $t$-channel singularities.  Here, the default value is $100\;\GeV$, so
 amplitudes with $W$ and $Z$ in the $t$-channel are considered as
 logarithmically enhanced. For a high-energy hadron collider of 40 or
 100 TeV energy, also $W$ and $Z$ in $s$-channel like situations might
 be necessary to be considered massless.
 
 Such logarithmic mappings need a dimensionful scale as parameter.  There are
 three such scales, all with default value $10\;\GeV$: \verb|phs_e_scale|
 (energy), \verb|phs_m_scale| (invariant mass), and \verb|phs_q_scale|
 (momentum transfer).  If cuts and/or masses are such that energies, invariant
 masses of particle pairs, and momentum transfer values below $10\;\GeV$ are
 excluded or suppressed, the values can be kept.  In special cases they should
 be changed: for instance, if you want to describe $\gamma^*\to\mu^+\mu^-$
 splitting well down to the muon mass, no cuts, you may set
 \verb|phs_m_scale = mmu|.  The convergence of the Monte-Carlo integration
 result will be considerably faster.
 
 There are more flags. These and more details about the phase space
 parameterization will be described in Sec.~\ref{sec:wood}.
 
 
 \subsection{Cuts}
 
 \whizard~2 does not apply default cuts to the integrand.  Therefore, processes
 with massless particles in the initial, intermediate, or final states may not
 have a finite cross section.  This fact will manifest itself in an integration
 that does not converge, or is unstable, or does not yield a reasonable error
 or reweighting efficiency even for very large numbers of iterations or calls
 per iterations.  When doing any calculation, you should verify first that the
 result that you are going to compute is finite on physical grounds.  If not,
 you have to apply cuts that make it finite.
 
 A set of cuts is defined by the \ttt{cuts} statement.  Here is an example
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 cuts = all Pt > 20 GeV [colored]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 This implies that events are kept only (for integration and simulation) if the
 transverse momenta of all colored particles are above $20\;\GeV$.
 
 Technically, \ttt{cuts} is a special object, which is unique within a given
 scope, and is defined by the logical expression on the right-hand side of the
 assignment.  It may be defined in global scope, so it is applied to all
 subsequent processes.  It may be redefined by another \ttt{cuts} statement.
 This overrides the first cuts setting: the \ttt{cuts} statement is not
 cumulative.  Multiple cuts should be specified by the logical operators of
 \sindarin, for instance
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 cuts = all Pt > 20 GeV [colored]
   and all E > 5 GeV [photon]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Cuts may also be defined local to an \ttt{integrate} command, i.e., in the
 options in braces.   They will apply only to the processes being integrated,
 overriding any global cuts.
 
 The right-hand side expression in the \ttt{cuts} statement is evaluated at the
 point where it is used by an \ttt{integrate} command (which could be an
 implicit one called by \ttt{simulate}).  Hence, if the logical expression
 contains parameters, such as
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 mH = 120 GeV
 cuts = all M > mH [b, bbar]
 mH = 150 GeV
 integrate (myproc)
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 the Higgs mass value that is inserted is the value in place when
 \ttt{integrate} is evaluated, $150\;\GeV$ in this example.  This same value
 will also be used when the process is called by a subsequent \ttt{simulate};
 it is \ttt{integrate} which compiles the cut expression and stores it among
 the process data.  This behavior allows for scanning over parameters without
 redefining the cuts every time.
 
 The cut expression can make use of all variables and constructs that are
 defined at the point where it is evaluated.  In particular, it can make use of
 the particle content and kinematics of the hard process, as in the example
 above.  In addition to the predefined variables and those defined by the user,
 there are the following variables which depend on the hard process:
 \begin{quote}
 \begin{tabular}{ll}
 integer: & \ttt{n\_in}, \ttt{n\_out}, \ttt{n\_tot} \\
 real: & \ttt{sqrts}, \ttt{sqrts\_hat}
 \end{tabular}
 \end{quote}
 Example:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 cuts = sqrts_hat > 150 GeV
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 The constants \ttt{n\_in} etc.\ are sometimes useful if a generic set of cuts
 is defined, which applies to various processes simultaneously.
 
 The user is encouraged to define his/her own set of cuts, if possible in a
 process-independent manner, even if it is not required.  The \ttt{include}
 command allows for storing a set of cuts in a separate \sindarin\ script which
 may be read in anywhere.  As an example, the system directories contain a file
 \verb|default_cuts.sin| which may be invoked by
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 include ("default_cuts.sin")
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 
 
 \subsection{QCD scale and coupling}
 
 \whizard\ treats all physical parameters of a model, the coefficients in the
 Lagrangian, as constants.  As a leading-order program, \whizard\ does not make
 use of running parameters as they are described by renormalization theory.
 For electroweak interactions where the perturbative expansion is sufficiently
 well behaved, this is a consistent approach.
 
 As far as QCD is concerned, this approach does not yield numerically
 reliable results, even on the validity scale of the tree approximation.
 In \whizard\ttt{2}, it is therefore possible to replace the fixed value of
 $\alpha_s$ (which is accessible as the intrinsic model variable
 \verb|alphas|), by a function of an energy scale $\mu$.
 
 This is controlled by the parameter \verb|?alphas_is_fixed|, which is
 \ttt{true} by default.  Setting it to \ttt{false} enables running~$\alpha_s$.
 The user has then to decide how $\alpha_s$ is calculated.
 
 One option is to set \verb|?alphas_from_lhapdf| (default \ttt{false}).  This
 is recommended if the \lhapdf\ library is used for including structure
 functions, but it may also be set if \lhapdf\ is not invoked.  \whizard\ will
 then use the $\alpha_s$ formula and value that matches the active
 \lhapdf\ structure function set and member.
 
 In the very same way, the $\alpha_s$ running from the PDFs implemented
 intrinsically in \whizard\ can be taken by setting
 \verb|?alphas_from_pdf_builtin| to \ttt{true}. This is the same
 running then the one from \lhapdf, if the intrinsic PDF coincides with
 a PDF chosen from \lhapdf.
 
 If this is not appropriate, there are again two possibilities.  If
 \verb|?alphas_from_mz| is \ttt{true}, the user input value \verb|alphas| is
 interpreted as the running value $\alpha_s(m_Z)$, and for the particular
 event, the coupling is evolved to the appropriate scale $\mu$.  The formula is
 controlled by the further parameters \verb|alphas_order| (default $0$,
 meaning leading-log; maximum $2$) and \verb|alphas_nf| (default $5$).
 
 Otherwise there is the option to set \verb|?alphas_from_lambda_qcd = true|
 in order to evaluate $\alpha_s$ from the scale $\Lambda_{\rm QCD}$,
 represented by the intrinsic variable \verb|lambda_qcd|. The reference
 value for the QCD scale is $\Lambda\_{\rm QCD} = 200$
 MeV. \verb|alphas_order| and \verb|alphas_nf| apply analogously.
 
 Note that for using one of the running options for $\alpha_s$, always
 \ttt{?alphas\_is\_fixed = false} has to be invoked.
 
 In any case, if $\alpha_s$ is not fixed, each event has to be assigned an
 energy scale.  By default, this is $\sqrt{\hat s}$, the partonic invariant
 mass of the event.  This can be replaced by a user-defined scale, the special
 object \ttt{scale}.  This is assigned and used just like the \ttt{cuts}
 object.  The right-hand side is a real-valued expression.  Here is an example:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 scale = eval Pt [sort by -Pt [colored]]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 This selects the $p_T$ value of the first entry in the list of colored
 particles sorted by decreasing $p_T$, i.e., the $p_T$ of the hardest jet.
 
 The \ttt{scale} definition is used not just for running $\alpha_s$ (if
 enabled), but it is also the factorization scale for the \lhapdf\ structure
 functions.
 
 These two values can be set differently by specifying
 \ttt{factorization\_scale} for the scale at which the PDFs are
 evaluated. Analogously, there is a variable
 \ttt{renormalization\_scale} that sets the scale value for the running
 $\alpha_s$. Whenever any of these two values is set, it supersedes the
 \ttt{scale} value.
 
 Just like the \ttt{cuts} expression, the expressions for \ttt{scale},
 \ttt{factorization\_scale} and also \ttt{renormalization\_scale}
 are evaluated at the point where it is read by an explicit or implicit
 \ttt{integrate} command.
 
 
 \subsection{Reweighting factor}
 
 It is possible to reweight the integrand by a user-defined function of the
 event kinematics.  This is done by specifying a \ttt{weight} expression.
 Syntax and usage is exactly analogous to the \ttt{scale} expression.  Example:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 weight = eval (1 + cos (Theta) ^ 2) [lepton]
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 We should note that the phase-space setup is not aware of this reweighting, so
 in complicated cases you should not expect adaptation to achieve as accurate
 results as for plain cross sections.
 
 Needless to say, the default \ttt{weight} is unity.
 
 
 \section{Events}
 
 After the cross section integral of a scattering process is known (or the
 partial-width integral of a decay process), \whizard\ can generate event
 samples.  There are two limiting cases or modes of event generation:
 \begin{enumerate}
 \item
   For a physics simulation, one needs \emph{unweighted} events, so the
   probability of a process and a kinematical configuration in the event sample
   is given by its squared matrix element.
 \item
   Monte-Carlo integration yields \emph{weighted} events, where the probability
   (without any grid adaptation) is uniformly distributed over phase space,
   while the weight of the event is given by its squared matrix element.
 \end{enumerate}
 The choice of parameterizations and the iterative adaptation of the
 integration grids gradually shift the generation mode from option 2 to option
 1, which obviously is preferred since it simulates the actual outcome of an
 experiment.  Unfortunately, this adaptation is perfect only in trivial cases,
 such that the Monte-Carlo integration yields non-uniform probability still
 with weighted events.  Unweighted events are obtained by rejection, i.e.,
 accepting an event with a probability equal to its own weight divided by the
 maximal possible weight.  Furthermore, the maximal weight is never precisely
 known, so this probability can only be estimated.
 
 The default generation mode of \whizard\ is unweighted.  This is controlled by
 the parameter \verb|?unweighted| with default value \ttt{true}.  Unweighted
 events are easy to interpret and can be directly compared with experiment, if
 properly interfaced with detector simulation and analysis.
 
 However, when applying rejection to generate unweighted events, the generator
 discards information, and for a single event it needs, on the average,
 $1/\epsilon$ calls, where the efficiency $\epsilon$ is the ratio of the
 average weight over the maximal weight.  If \verb|?unweighted| is \ttt{false},
 all events are kept and assigned their respective weights in histograms or
 event files.
 
 
 \subsection{Simulation}
 \label{sec:simulation}
 
 The \ttt{simulate} command generates an event sample.  The number of events
 can be set either by specifying the integer variable \verb|n_events|, or by
 the real variable \verb|luminosity|.  (This holds for unweighted events.  If
 weighted events are requested, the luminosity value is ignored.)  The
 luminosity is measured in
 femtobarns, but other units can be used, too.  Since the cross sections for the
 processes are known at that point, the number of events is determined as the
 luminosity multiplied by the cross section.
 
 As usual, both parameters can be set either as global or as local parameters:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   n_events = 10000
   simulate (proc1)
   simulate (proc2, proc3) { luminosity = 100 / 1 pbarn }
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 In the second example, both \verb|n_events| and \verb|luminosity| are set.
 In that case, \whizard\ chooses whatever produces the larger number of events.
 
 If more than one process is specified in the argument of \ttt{simulate},
 events are distributed among the processes with fractions proportional to
 their cross section values.  The processes are mixed randomly, as it would be
 the case for real data.
 
 The raw event sample is written to a file which is named after the first process
 in the argument of \ttt{simulate}.  If the process name is \ttt{proc1}, the
 file will be named \ttt{proc1.evx}.  You can choose another basename by the
 string variable \verb|$sample|.  For instance,
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   simulate (proc1) { n_events = 4000  $sample = "my_events" }
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 will produce an event file \verb|my_events.evx| which contains $4000$ events.
 
 This event file is in a machine-dependent binary format, so it is not of
 immediate use.  Its principal purpose is to serve as a cache: if you re-run
 the same script, before starting simulation, it will look for an existing
 event file that matches the input.  If nothing has changed, it will find the
 file previously generated and read in the events, instead of generating them.
 Thus you can modify the analysis or any further steps without repeating the
 time-consuming task of generating a large event sample.  If you change the
 number of events to generate, the program will make use of the existing event
 sample and generate further events only when it is used up.  If necessary, you
 can suppress the writing/reading of the raw event file by the parameters
 \verb|?write_raw| and \verb|?read_raw|.
 
 If you try to reuse an event file that has been written by a previous version
 of \whizard, you may run into an incompatibility, which will be detected as an
 error.  If this happens, you may enforce a compatibility mode (also for
 writing) by setting \ttt{\$event\_file\_version} to the appropriate version
 string, e.g., \verb|"2.0"|.  Be aware that this may break some more recent
 features in the event analysis.
 
 Generating an event sample can serve several purposes.  First of all,
 it can be analyzed directly, by \whizard's built-in capabilities, to
 produce tables, histograms, or calculate inclusive observables.  The
 basic analysis features of \whizard\ are described below in
 Sec.~\ref{sec:analysis}.  It can be written to an external file in a
 standard format that a human or an external program can understand.
 In Chap.~\ref{chap:events}, you will find a more thorough discussion
 of event generation with \whizard, which also covers in detail the
 available event-file formats.  Finally, \whizard\ can rescan an
 existing event sample.  The event sample may either be the result of a
 previous \ttt{simulate} run or, under certain conditions, an external
 event sample produced by another generator or reconstructed from
 data.
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 rescan "my_events" (proc1) { $pdf_builtin_set = "MSTW2008LO" }
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 The rescanning may apply different parameters and recalculate the
 matrix element, it may apply a different event selection, it may
 reweight the events by a different PDF set (as above).  The modified
 event sample can again be analyzed or written to file.  For more
 details, cf.\ Sec.~\ref{sec:rescan}.
 
 %%%%%%%%%%%%%%%
 
 \subsection{Decays}
 \label{sec:decays}
 
 Normally, the events generated by the \ttt{simulate} command will be identical
 in structure to the events that the \ttt{integrate} command generates.  This
 implies that for a process such as $pp\to W^+W^-$, the final-state particles
 are on-shell and stable, so they appear explicitly in the generated event
 files.  If events are desired where the decay products of the $W$ bosons
 appear, one has to generate another process, e.g., $pp\to u\bar d\bar ud$.  In
 this case, the intermediate vector bosons, if reconstructed, are off-shell as
 dictated by physics, and the process contains all intermediate states that are
 possible.  In this example, the matrix element contains also $ZZ$, photon, and
 non-resonant intermediate states.  (This can be restricted via the
 \verb|$restrictions| option, cf.\ \ref{sec:process options}.
 
 Another approach is to factorize the process in production (of $W$ bosons) and
 decays ($W\to q\bar q$).  This is actually the traditional approach, since it
 is much less computing-intensive.  The factorization neglects all off-shell
 effects and irreducible background diagrams that do not have the decaying
 particles as an intermediate resonance.  While \whizard\ is able to deal with
 multi-particle processes without factorization, the needed computing resources
 rapidly increase with the number of external particles. Particularly,
 it is the phase space integration that becomes the true bottleneck for
 a high multiplicity of final state particles.
 
 In order to use the factorized approach, one has to specify particles
 as \ttt{unstable}.  (Also, the \ttt{?allow\_decays} switch must be \ttt{true};
 this is however its default value.)  We give an example for a $pp \to Wj$ final
 state:
 \begin{code}
 process wj  = u, gl => d, Wp
 process wen = Wp => E1, n1
 
 integrate (wen)
 
 sqrts = 7 TeV
 beams = p, p => pdf_builtin
 unstable Wp (wen)
 simulate (wj) { n_events = 1 }
 \end{code}
 This defines a $2 \to 2$ hard scattering process of $W + j$ production
 at the 7 TeV LHC 2011 run. The $W^+$ is marked as unstable, with its
 decay process being $W^+ \to e^+ \nu_e$. In the \ttt{simulate} command
 both processes, the production process \ttt{wj} and the decay process
 \ttt{wen} will be integrated, while the $W$ decays become effective
 only in the final event sample. This event sample will contain final
 states with multiplicity $3$, namely $e^+ \nu_e d$. Note that here
 only one decay process is given, hence the branching ratio for the
 decay will be taken to be $100 \%$ by \whizard.
 
 A natural restriction of the factorized approach is the implied narrow-width
 approximation.  Theoretically, this restriction is necessary since whenever
 the width plays an important role, the usage of the factorized approach will
 not be fully justified.  In particular, all involved matrix elements must be
 evaluated on-shell, or otherwise gauge-invariance issues could spoil the
 calculation.  (There are plans for a future \whizard\ version
 to also include Breit-Wigner or Gaussian distributions when using the
 factorized approach.)
 
 Decays can be concatenated, e.g. for top pair production and
 decay, $e^+ e^- \to t \bar t$ with decay $t \to W^+ b$, and subsequent
 leptonic decay of the $W$ as in $W^+ \to \mu^+ \nu_\mu$:
 \begin{code}
 process eett = e1, E1 => t, tbar
 process t_dec = t => Wp, b
 process W_dec = Wp => E2, n2
 
 unstable t (t_dec)
 unstable Wp (W_dec)
 
 sqrts = 500
 simulate (eett) { n_events = 1 }
 \end{code}
 Note that in this case the final state in the event file will consist
 of $\bar t b \mu^+ \nu_\mu$ because the anti-top is not decayed.
 
 If more than one decay process is being specified like in
 \begin{code}
   process eeww = e1, E1 => Wp, Wm
   process w_dec1 = Wp => E2, n2
   process w_dec2 = Wp => E3, n3
 
   unstable Wp (w_dec1, w_dec2)
 
   sqrts = 500
   simulate (eeww) { n_events = 100 }
 \end{code}
 then \whizard\ takes the integrals of the specified decay processes
 and distributes the decays statistically according to the calculated
 branching ratio. Note that this might not be the true branching ratios
 if decay processes are missing, or loop corrections to partial widths
 give large(r) deviations. In the calculation of the code above,
 \whizard\ will issue an output like
 \begin{code}
 | Unstable particle W+: computed branching ratios:
 |   w_dec1: 5.0018253E-01   mu+, numu
 |   w_dec2: 4.9981747E-01   tau+, nutau
 |   Total width = 4.5496085E-01 GeV (computed)
 |               = 2.0490000E+00 GeV (preset)
 |   Decay options: helicity treated exactly
 \end{code}
 So in this case, \whizard\ uses 50 \% muonic and 50 \% tauonic decays
 of the positively charged $W$, while the $W^-$ appears directly in the
 event file. \whizard\ shows the difference between the preset $W$
 width from the physics model file and the value computed from the two
 decay channels.
 
 Note that a particle in a \sindarin\ input script can be also explictly
 marked as being stable, using the
 \begin{code}
 stable <particle-tag>
 \end{code}
 constructor for the particle \ttt{<particle-tag>}.
 
 
 \subsubsection{Resetting branching fractions}
 \label{sec:br-reset}
 
 As described above, decay processes that appear in a simulation must
 first be integrated by the program, either explicitly via the
 \verb|integrate| command, or implicitly by \verb|unstable|.  In either
 case, \whizard\ will use the computed partial widths in order to
 determine branching fractions.  In the spirit of a purely leading-order
 calculation, this is consistent.
 
 However, it may be desired to rather use different branching-fraction
 values for the decays of a particle, for instance, NLO-corrected
 values.  In fact, after \whizard\ has integrated any process, the
 integration result becomes available as an ordinary
 \sindarin\ variable.  For instance, if a decay process has the ID
 \verb|h_bb|, the integral of this process -- the partial width, in
 this case -- becomes the variable \verb|integral(h_bb)|.  This
 variable may be reset just like any other variable:
 \begin{code}
   integral(h_bb) = 2.40e-3 GeV
 \end{code}
 The new value will be used for all subsequent Higgs branching-ratio
 calculations and decays, if an unstable Higgs appears in a process for
 simulation.
 
 
 \subsubsection{Spin correlations in decays}
 \label{sec:spin-correlations}
 
 By default, \whizard\ applies full spin and color correlations to the
 factorized processes, so it keeps both color and spin coherence between
 productions and decays.  Correlations between decay products of distinct
 unstable particles in the same event are also fully retained.  The program
 sums over all intermediate quantum numbers.
 
 Although this approach obviously yields the optimal description with the
 limits of production-decay factorization, there is support for a simplified
 handling of particle decays.  Essentially, there are four options, taking a
 decay \ttt{W\_ud}: $W^-\to \bar u d$ as an example:
 \begin{enumerate}
 \item
   Full spin correlations: \verb|unstable Wp (W_ud)|
 \item
   Isotropic decay: \verb|unstable Wp (W_ud) { ?isotropic_decay = true }|
 \item
   Diagonal decay matrix:
   \verb|unstable Wp (W_ud) { ?diagonal_decay = true }|
 \item
   Project onto specific helicity:
   \verb|unstable Wp (W_ud) { decay_helicity = -1 }|
 \end{enumerate}
 Here, the isotropic option completely eliminates spin correlations.  The
 diagonal-decays option eliminates just the off-diagonal entries of the $W$
 spin-density matrix.  This is equivalent to a measurement of spin before the
 decay.  As a result, spin correlations are still present in the classical
 sense, while quantum coherence is lost.  The definite-helicity option is
 similar and additional selects only the specified helicity component for the
 decaying particle, so its decay distribution assumes the shape for an
 accordingly polarized particle.  All options apply in the rest frame of the
 decaying particle, with the particle's momentum as the quantization axis.
 
 \subsubsection{Automatic decays}
 
 A convenient option is if the user did not have to specify the decay
 mode by hand, but if they were generated automatically. \whizard\ does
 have this option: the flag \ttt{?auto\_decays} can be set to
 \ttt{true}, and is taking care of that. In that case the list for the
 decay processes of the particle marked as unstable is left empty (we
 take a $W^-$ again as example):
 \begin{code}
 unstable Wm () { ?auto_decays = true }
 \end{code}
 \whizard\ then inspects at the local position within the \sindarin\
 input file where that \ttt{unstable} statement appears the masses of
 all the particles of the active physics model in order to determine
 which decays are possible. It then calculates their partial widths.
 There are a few options to customize the decays. The integer variable
 \ttt{auto\_decays\_multiplicity} allows to set the maximal
 multiplicity of the final states considered in the auto decay
 option. The defaul value of that variable is \ttt{2}; please be quite
 careful when setting this to values larger than that. If you do so,
 the flag \ttt{?auto\_decays\_radiative} allows to specify whether
 final states simply containing additional resolved gluons or photons
 are taken into account or not. For the example above, you almost hit
 the PDG value for the $W$ total width:
 \begin{code}
 | Unstable particle W-: computed branching ratios:
 |   decay_a24_1: 3.3337068E-01   d, ubar
 |   decay_a24_2: 3.3325864E-01   s, cbar
 |   decay_a24_3: 1.1112356E-01   e-, nuebar
 |   decay_a24_4: 1.1112356E-01   mu-, numubar
 |   decay_a24_5: 1.1112356E-01   tau-, nutaubar
 |   Total width = 2.0478471E+00 GeV (computed)
 |               = 2.0490000E+00 GeV (preset)
 |   Decay options: helicity treated exactly
 \end{code}
 
 \subsubsection{Future shorter notation for decays}
 
 {\color{red} In an upcoming \whizard\ version there will be a shorter and more
   concise notation already in the process definition for such decays,
   which, however, is current not yet implemented. The two first examples
   above will then be shorter and have this form:}
   \begin{code}
     process wj = u, gl => (Wp => E1, n1), d
   \end{code}
   {\color{red} as well as }
   \begin{code}
     process eett = e1, E1 => (t => (Wp => E2, n2), b), tbar
   \end{code}
 
 %%%%%
 
 \subsection{Event formats}
 
 As mentioned above, the internal \whizard\ event format is a
 machine-dependent event format. There are a series of human-readable
 ASCII event formats that are supported: very verbose formats intended
 for debugging, formats that have been agreed upon during the Les
 Houches workshops like LHA and LHEF, or formats that are steered
 through external packages like HepMC. More details about event formats
 can be found in Sec.~\ref{sec:eventformats}.
 
 %%%%%%%%%%%%%%%
 
 \section{Analysis and Visualization}
 \label{sec:analysis}
 
 \sindarin\ natively supports basic methods of data analysis and visualization
 which are frequently used in high-energy physics studies.  Data generated
 during script execution, in particular simulated event samples, can be
 analyzed to evaluate further observables, fill histograms, and draw
 two-dimensional plots.
 
 So the user does not have to rely on his/her own external graphical
 analysis method (like e.g. \ttt{gnuplot} or \ttt{ROOT} etc.), but can
 use methods that automatically ship with \whizard. In many cases, the
 user, however, clearly will use his/her own analysis machinery,
 especially experimental collaborations.
 
 In the following sections, we first summarize the available data structures,
 before we consider their graphical display.
 
 
 
 \subsection{Observables}
 
 Analyses in high-energy physics often involve averages of quantities other
 than a total cross section.  \sindarin\ supports this by its \ttt{observable}
 objects.  An \ttt{observable} is a container that collects a single
 real-valued variable with a statistical distribution.  It is declared by a
 command of the form
 \begin{quote}
   \begin{footnotesize}
 \ttt{observable \emph{analysis-tag}}
   \end{footnotesize}
 \end{quote}
 where \ttt{\emph{analysis-tag}} is an identifier that follows the same rules
 as a variable name.
 
 Once the observable has been declared, it can be filled with values.  This is
 done via the \ttt{record} command:
 \begin{quote}
   \begin{footnotesize}
 \ttt{record \emph{analysis-tag} (\emph{value})}
   \end{footnotesize}
 \end{quote}
 To make use of this, after values have been filled, we want to perform the
 actual analysis and display the results.  For an observable, these are the
 mean value and the standard deviation.  There is the command
 \ttt{write\_analysis}:
 \begin{quote}
   \begin{footnotesize}
 \ttt{write\_analysis (\emph{analysis-tag})}
   \end{footnotesize}
 \end{quote}
 
 Here is an example:
 \begin{quote}
   \begin{footnotesize}
 \begin{verbatim}
 observable obs
 record obs (1.2)  record obs (1.3)  record obs (2.1)  record obs (1.4)
 write_analysis (obs)
 \end{verbatim}
   \end{footnotesize}
 \end{quote}
 The result is displayed on screen:
 \begin{quote}
   \begin{footnotesize}
 \begin{verbatim}
 ###############################################################################
 # Observable: obs
 average     =  1.500000000000E+00
 error[abs]  =  2.041241452319E-01
 error[rel]  =  1.360827634880E-01
 n_entries   = 4
 \end{verbatim}
   \end{footnotesize}
 \end{quote}
 
 
 \subsection{The analysis expression}
 \label{subsec:analysis}
 
 The most common application is the computation of event observables -- for
 instance, a forward-backward asymmetry -- during simulation.  To this end,
 there is an \ttt{analysis} expression, which behaves very similar to the
 \ttt{cuts} expression.  It is defined either globally
 \begin{quote}
   \begin{footnotesize}
     \ttt{analysis = \emph{logical-expr}}
   \end{footnotesize}
 \end{quote}
 or as a local option to the \ttt{simulate} or \ttt{rescan} commands which
 generate and handle event samples.  If this expression is defined, it is not
 evaluated immediately, but it is evaluated once for each event in the sample.
 
 In contrast to the \ttt{cuts} expression, the logical value of the
 \ttt{analysis} expression is discarded; the expression form has been chosen
 just by analogy.  To make this useful, there is a variant of the \ttt{record}
 command, namely a \ttt{record} function with exactly the same syntax.  As an
 example, here is a calculation of the forward-backward symmetry in a process
 \ttt{ee\_mumu} with final state $\mu^+\mu^-$:
 \begin{quote}
   \begin{footnotesize}
 \begin{verbatim}
   observable a_fb
   analysis = record a_fb (eval sgn (Pz) ["mu-"])
   simulate (ee_mumu) { luminosity = 1 / 1 fbarn }
 \end{verbatim}
   \end{footnotesize}
 \end{quote}
 The logical return value of \ttt{record} -- which is discarded here -- is
 \ttt{true} if the recording was successful.  In case of histograms (see below)
 it is true if the value falls within bounds, false otherwise.
 
 Note that the function version of \ttt{record} can be used anywhere in
 expressions, not just in the \ttt{analysis} expression.
 
 When \ttt{record} is called for an observable or histogram in simulation mode,
 the recorded value is weighted appropriately.  If \ttt{?unweighted} is true,
 the weight is unity, otherwise it is the event weight.
 
 The \ttt{analysis} expression can involve any other construct
 that can be expressed as an expression in \sindarin.  For instance, this
 records the energy of the 4th hardest jet in a histogram \ttt{pt\_dist}, if it
 is in the central region:
 \begin{quote}
   \begin{footnotesize}
 \begin{verbatim}
   analysis =
     record pt_dist (eval E [extract index 4
                              [sort by - Pt
                                [select if -2.5 < Eta < 2.5 [colored]]]])
 \end{verbatim}
   \end{footnotesize}
 \end{quote}
 Here, if there is no 4th jet in the event which satisfies the criterion, the
 result will be an undefined value which is not recorded.  In that case,
 \ttt{record} evaluates to \ttt{false}.
 
 Selection cuts can be part of the analysis expression:
 \begin{code}
   analysis =
     if any Pt > 50 GeV [lepton] then
       record jet_energy (eval E [collect [jet]])
     endif
 \end{code}
 Alternatively, we can specify a separate selection expression:
 \begin{code}
   selection = any Pt > 50 GeV [lepton]
   analysis = record jet_energy (eval E [collect [jet]])
 \end{code}
 The former version writes all events to file (if requested), but
 applies the analysis expression only to the selected events.  This
 allows for the simultaneous application of different selections to a
 single event sample.  The latter version applies the selection to all
 events before they are analyzed or written to file.
 
 The analysis expression can make use of all variables and constructs that are
 defined at the point where it is evaluated.  In particular, it can make use of
 the particle content and kinematics of the hard process, as in the example
 above.  In addition to the predefined variables and those defined by the user,
 there are the following variables which depend on the hard process.  Some of
 them are constants, some vary event by event:
 \begin{quote}
 \begin{tabular}{ll}
 integer: &\ttt{event\_index} \\
 integer: &\ttt{process\_num\_id} \\
 string: &\ttt{\$process\_id} \\
 integer: &\ttt{n\_in}, \ttt{n\_out}, \ttt{n\_tot} \\
 real: &\ttt{sqrts}, \ttt{sqrts\_hat} \\
 real: &\ttt{sqme}, \ttt{sqme\_ref} \\
 real: &\ttt{event\_weight}, \ttt{event\_excess}
 \end{tabular}
 \end{quote}
 The \ttt{process\_num\_id} is the numeric ID as used by external
 programs, while the process index refers to the current library. By
 default, the two are identical.  The process index itself is not
 available as a predefined observable. The \ttt{sqme} and
 \ttt{sqme\_ref} values indicate the squared matrix element and the
 reference squared matrix element, respectively.  The latter applies
 when comparing with a reference sample (the \ttt{rescan} command).
 
 \ttt{record} evaluates to a logical, so several \ttt{record} functions may
 be concatenated by the logical operators \ttt{and} or \ttt{or}.  However,
 since usually the further evaluation should not depend on the return value of
 \ttt{record}, it is more advisable to concatenate them by the semicolon
 (\ttt{;}) operator.  This is an operator (\emph{not} a statement separator or
 terminator) that connects two logical expressions and evaluates both of them
 in order.  The lhs result is discarded, the result is the value of the rhs:
 \begin{quote}
   \begin{footnotesize}
 \begin{verbatim}
   analysis =
     record hist_pt (eval Pt [lepton]) ; record hist_ct (eval cos (Theta) [lepton])
 \end{verbatim}
   \end{footnotesize}
 \end{quote}
 
 
 \subsection{Histograms}
 \label{sec:histogram}
 
 In \sindarin, a histogram is declared by the command
 \begin{quote}
   \begin{footnotesize}
 \ttt{histogram \emph{analysis-tag} (\emph{lower-bound}, \emph{upper-bound})}
   \end{footnotesize}
 \end{quote}
 This creates a histogram data structure for an (unspecified) observable.  The
 entries are organized in bins between the real values \ttt{\emph{lower-bound}}
 and \ttt{\emph{upper-bound}}.  The number of bins is given by the value of the
 intrinsic integer variable \ttt{n\_bins}, the default value is 20.
 
 The \ttt{histogram} declaration supports an optional argument, so the number
 of bins can be set locally, for instance
 \begin{quote}
   \begin{footnotesize}
 \ttt{histogram pt\_distribution (0 GeV, 500 GeV) \{ n\_bins = 50 \}}
   \end{footnotesize}
 \end{quote}
 Sometimes it is more convenient to set the bin width directly.  This can be
 done in a third argument to the \ttt{histogram} command.
 \begin{quote}
   \begin{footnotesize}
 \ttt{histogram pt\_distribution (0 GeV, 500 GeV, 10 GeV)}
   \end{footnotesize}
 \end{quote}
 If the bin width is specified this way, it overrides the setting of
 \ttt{n\_bins}.
 
 The \ttt{record} command or function fills histograms.  A single call
 \begin{quote}
   \begin{footnotesize}
 \ttt{record (\emph{real-expr})}
   \end{footnotesize}
 \end{quote}
 puts the value of \ttt{\emph{real-expr}} into the appropriate bin.  If
 the call is issued during a simulation where \ttt{unweighted} is false, the
 entry is weighted appropriately.
 
 If the value is outside the range specified in the histogram declaration, it
 is put into one of the special underflow and overflow bins.
 
 The \ttt{write\_analysis} command prints the histogram contents as a table in
 blank-separated fixed columns.  The columns are: $x$ (bin midpoint), $y$ (bin
 contents), $\Delta y$ (error), excess weight, and $n$ (number of entries).
 The output also contains comments initiated by a \verb|#| sign, and following
 the histogram proper, information about underflow and overflow as well as
 overall contents is added.
 
 
 \subsection{Plots}
 \label{sec:plot}
 
 While a histogram stores only summary information about a data set, a
 \ttt{plot} stores all data as $(x,y)$ pairs, optionally with errors.  A plot
 declaration is as simple as
 \begin{quote}
   \begin{footnotesize}
 \ttt{plot \emph{analysis-tag}}
   \end{footnotesize}
 \end{quote}
 Like observables and histograms, plots are filled by the \ttt{record} command
 or expression.  To this end, it can take two arguments,
 \begin{quote}
   \begin{footnotesize}
 \ttt{record (\emph{x-expr}, \emph{y-expr})}
   \end{footnotesize}
 \end{quote}
 or up to four:
 \begin{quote}
   \begin{footnotesize}
 \ttt{record (\emph{x-expr}, \emph{y-expr}, \emph{y-error})}
 \\
 \ttt{record (\emph{x-expr}, \emph{y-expr},
   \emph{y-error-expr}, \emph{x-error-expr})}
   \end{footnotesize}
 \end{quote}
 Note that the $y$ error comes first.  This is because applications will
 demand errors for the $y$ value much more often than $x$ errors.
 
 The plot output, again written by \ttt{write\_analysis} contains the four
 values for each point, again in the ordering $x,y,\Delta y, \Delta x$.
 
 
 \subsection{Analysis Output}
 
 There is a default format for piping information into observables,
 histograms, and plots. In older versions of \whizard\ there was a
 first version of a custom format, which was however rather limited.
 A more versatile custom output format will be coming soon.
 
 \begin{enumerate}
 \item
 By default, the \ttt{write\_analysis} command prints all data to the
 standard output. The data are also written to a default file with the
 name \ttt{whizard\_analysis.dat}.
 Output is redirected to a file with a different name if the
 variable \ttt{\$out\_file} has a nonempty value.  If the file is
 already open, the output will be appended to
 the file, and it will be kept open.  If the file is not open,
 \ttt{write\_analysis} will open the output file by itself, overwriting any
 previous file with the same name, and close it again after data have been
 written.
 
 The command is able to print more than one dataset, following the syntax
 \begin{quote}
   \begin{footnotesize}
   \ttt{write\_analysis (\emph{analysis-tag1}, \emph{analysis-tag2}, \ldots)
   \{ \emph{options} \}}
   \end{footnotesize}
 \end{quote}
 The argument in brackets may also be empty or absent; in this case, all
 currently existing datasets are printed.
 
 The default data format is suitable for compiling analysis data by \whizard's
 built-in \gamelan\ graphics driver (see below and particularly
 Chap.~\ref{chap:visualization}).  Data are written in
 blank-separated fixed columns, headlines and comments are initiated by the
 \verb|#| sign, and each data set is terminated by a blank line.  However,
 external programs often require special formatting.
 
 The internal graphics driver \gamelan\ of \whizard\ is initiated by
 the \ttt{compile\_analysis} command. Its syntax is the same, and it
 contains the \ttt{write\_analysis} if that has not been separately
 called (which is unnecessary). For more details about the \gamelan\
 graphics driver and data visualization within \whizard, confer
 Chap.~\ref{chap:visualization}.
 
 \item
 Custom format. Not yet (re-)implemented in a general form.
 \end{enumerate}
 
 
 \section{Custom Input/Output}
 \label{sec:I/O}
 
 \whizard\ is rather chatty.  When you run examples or your own scripts, you
 will observe that the program echoes most operations (assignments, commands,
 etc.) on the standard output channel, i.e., on screen.  Furthermore, all
 screen output is copied to a log file which by default is named
 \ttt{whizard.log}.
 
 For each integration run, \whizard\ writes additional process-specific
 information to a file \ttt{\var{tag}.log}, where \ttt{\var{tag}} is the
 process name.  Furthermore, the \ttt{write\_analysis} command dumps analysis
 data -- tables for histograms and plots -- to its own set of files, cf.\
 Sec.~\ref{sec:analysis}.
 
 However, there is the occasional need to write data to extra files in a custom
 format.  \sindarin\ deals with that in terms of the following commands:
 
 \subsection{Output Files}
 
 \subsubsection{open\_out}
 \begin{syntax}
 open\_out (\var{filename}) \\
 open\_out (\var{filename}) \{ \var{options} \}
 \end{syntax}
 Open an external file for writing.  If the file exists, it is overwritten
 without warning, otherwise it is created.  Example:
 \begin{code}
 open_out ("my_output.dat")
 \end{code}
 
 
 \subsubsection{close\_out}
 \begin{syntax}
 close\_out (\var{filename}) \\
 close\_out (\var{filename}) \{ \var{options} \}
 \end{syntax}
 Close an external file that is open for writing.  Example:
 \begin{code}
 close_out ("my_output.dat")
 \end{code}
 
 
 \subsection{Printing Data}
 
 \subsubsection{printf}
 \begin{syntax}
 printf \var{format-string-expr} \\
 printf \var{format-string-expr} (\var{data-objects})
 \end{syntax}
 Format \ttt{\var{data-objects}} according to \ttt{\var{format-string-expr}}
 and print the resulting string to standard output if the string variable
 \ttt{\$out\_file} is undefined.  If \ttt{\$out\_file} is defined and the file
 with this name is open for writing, print to this file instead.
 
 Print a newline at the end if \ttt{?out\_advance} is true, otherwise don't
 finish the line.
 
 The \ttt{\var{format-string-expr}} must evaluate to a string.  Formatting
 follows a subset of the rules for the \ttt{printf(3)} command in the \ttt{C}
 language.  The supported rules are:
 \begin{itemize}
 \item All characters are printed as-is, with the exception of embedded
   conversion specifications.
 \item Conversion specifications are initiated by a percent (\verb|%|) sign and
   followed by an optional prefix flag, an optional integer value, an optional
   dot followed by another integer, and a mandatory letter as the conversion
   specifier.
 \item A percent sign immediately followed by another percent sign is
   interpreted as a single percent sign, not as a conversion specification.
 \item The number of conversion specifiers must be equal to the number of data
   objects.  The data types must also match.
 \item The first integer indicates the minimum field width, the second one the
   precision.  The field is expanded as needed.
 \item The conversion specifiers \ttt{d} and \ttt{i} are equivalent, they
   indicate an integer value.
 \item The conversion specifier \ttt{e} indicates a real value that should be
   printed in exponential notation.
 \item The conversion specifier \ttt{f} indicates a real value that should be
   printed in decimal notation without exponent.
 \item The conversion specifier \ttt{g} indicates a real value that should be
   printed either in exponential or in decimal notation, depending on its
   value.
 \item The conversion specifier \ttt{s} indicates a logical or string value
   that should be printed as a string.
 \item Possible prefixes are \verb|#| (alternate form, mandatory decimal point
   for reals), \verb|0| (zero padding), \verb|-| (left adjusted), \verb|+|
   (always print sign), `\verb| |' (print space before a positive number).
 \end{itemize}
 For more details, consult the \verb|printf(3)| manpage.  Note that other
 conversions are not supported and will be rejected by \whizard.
 
 The data arguments are numeric, logical or string variables or expressions.
 Numeric expressions must be enclosed in parantheses.  Logical expressions must
 be enclosed in parantheses prefixed by a question mark \verb|?|.  String
 expressions must be enclosed in parantheses prefixed by a dollar sign
 \verb|$|.  These forms behave as anonymous variables.
 
 Note that for simply printing a text string, you may call \ttt{printf} with
 just a format string and no data arguments.
 
 Examples:
 \begin{code}
 printf "The W mass is %8f GeV" (mW)
 
 int i = 2
 int j = 3
 printf "%i + %i = %i" (i, j, (i+j))
 
 string $directory = "/usr/local/share"
 string $file = "foo.dat"
 printf "File path: %s/%s" ($directory, $file)
 \end{code}
 There is a related \ttt{sprintf} function, cf.~Sec.~\ref{sec:sprintf}.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \section{WHIZARD at next-to-leading order}
 \subsection{Prerequisites}
 A full NLO computation requires virtual matrix elements obtained from
 loop diagrams. Since \oMega\ cannot calculate such diagrams, external
 programs are used.  \whizard\ has a generic interface to matrix-element
 generators that are BLHA-compatible.
 Explicit implementations exist for \gosam, \openloops\ and \recola.
 
 %%%%%
 
 \subsubsection{Setting up \gosam}
 
 The installation of \gosam\ is detailed on the HepForge page
 \url{https://gosam/hepforge.org}.  We mention here some of the steps
 necessary to get it to be linked with \whizard.
 
 {\bf Bug in \gosam\ installation scripts:} In many versions of
 \gosam\ there is a bug in the installation scripts that is only
 relevant if \gosam\ is installed with superuser privileges. Then all
 files in \ttt{\$installdir/share/golem} do not have read privileges
 for normal users. These privileges must be given manually to all files
 in that directory.
 
 Prerequisites for \gosam\ to produce code for one-loop matrix elements
 are the scientific algebra program \ttt{form} and the generator of
 loop topologies and diagrams, \ttt{qgraf}.
 These can be accessed via their respective webpages
 \url{http://www.nikhef.nl/~form/} and
 \url{http://cfif.ist.utl.pt/~paulo/qgraf.html}. Note also that both
 \ttt{Java} and the Java runtime environment have to be installed in
 order for \gosam\ to properly work.  Furthermore, \ttt{libtool}
 needs to be installed.  A more convenient way to install \gosam, is the
 automatic installation script
 \url{https://gosam.hepforge.org/gosam_installer.py}.
 
 %%%%%
 
 \subsubsection{Setting up \openloops}
 \label{sec:openloops-setup}
 
 The installation of \openloops\ is explained in detail on the HepForge
 page \url{https://openloops.hepforge.org}.  In the following, the main
 steps for usage with \whizard\ are summarized.
 
 Please note that at the moment, \openloops\ cannot be installed such
 that in almost all cases the explicit \openloops\ package directory
 has to be set via \ttt{--with-openloops=<openloops\_dir>}.
 
 \openloops\ can be checked out with
 \begin{code}
    svn co https://openloops.hepforge.org/svn/OpenLoops/branches/public
 \end{code}
 The program can be build by running \ttt{scons} or \ttt{./scons}, a
 local version that is included in the \openloops\ directory.  This
 produces the script \ttt{./openloops}, which is the main hook for the
 further usage of the program.
 
 \openloops\ works by downloading prebuild process libraries, which have
 to be installed for each individual process. This requires the file
 \ttt{openloops.cfg}, which should contain
 the following content:
 \begin{code}
    [OpenLoops]
    process\_repositories=public, whizard\\
    compile\_extra=1
 \end{code}
 The first line instructs \openloops\ to also look for process libraries
 in an additional lepton collider repository.  The second line triggers
 the inclusion of $N+1$-particle tree-level matrix elements in the
 process directory, so that a complete NLO calculation including real
 amplitudes can be performed only with \openloops.
 
 The libraries can then be installed via
 \begin{code}
    ./openloops libinstall proc_name
 \end{code}
 A list of supported library names can be found on the \openloops\ web
 page.  Note that a process library also includes all possible permutated
 processes.  The process library \ttt{ppll}, for example, can also be
 used to compute the matrix elements for $e^+ e^- \rightarrow q \bar{q}$
 (massless quarks only).  The massive case of the top quark is handled in
 \ttt{eett}.  Additionally, there are process libraries for top and gauge
 boson decays, \ttt{tbw}, \ttt{vjj}, \ttt{tbln} and \ttt{tbqq}.
 
 Finally, \openloops\ can be linked to \whizard\ during configuration by
 including
 \begin{code}
   --enable-openloops --with-openloops=$OPENLOOPS_PATH,
 \end{code}
 where \ttt{\$OPENLOOPS\_PATH} is the directory the \openloops\
 executable is located in.  \openloops\ one-loop diagrams can then be
 used with the \sindarin\ option
 \begin{code}
   $loop_me_method = "openloops".
 \end{code}
 The functional tests which check the \openloops\ functionality require
 the libraries \ttt{ppll}, \ttt{eett} and \ttt{tbw} to be installed (note
 that \ttt{eett} is not contained in \ttt{ppll}).  During the
 configuration of \whizard, it is automatically checked that these two
 libraries, as well as the option \ttt{compile\_extra=1}, are present.
 
 \subsubsection{\openloops\ \sindarin\ flags}
 Several \sindarin\ options exist to control the behavior of \openloops.
 \begin{itemize}
   \item \ttt{openloops\_verbosity}:\\
     Decide how much \openloops\ output is printed. Can have values 0, 1
     and 2.
   \item \ttt{?openloops\_use\_cms}:\\
     Activates the complex mass scheme. For computations with decaying
     resonances like the top quark or W or Z bosons, this is the
     preferred option to avoid gauge-dependencies.
   \item \ttt{openloops\_phs\_tolerance}:\\
     Controls the exponent of \ttt{extra psp\_tolerance} in the BLHA
     interface, which is the numerical tolerance for the on-shell
     condition of external particles
   \item \ttt{openloops\_switch\_off\_muon\_yukawa}:\\
     Sets the Yukawa coupling of muons to zero in order to assure
     agreement with \oMega, which is possibly used for other
     components and per default does not take $H\mu\mu$ couplings
     into account.
   \item \ttt{openloops\_stability\_log}:\\
     Creates the directory \ttt{stability\_log}, which contains information
     about the performance of the matrix elements. Possible values are
     \begin{itemize}
     \item 0: No output (default),
     \item 1: On finish() call,
     \item 2: Adaptive,
     \item 3: Always
    \end{itemize}
   \item \ttt{?openloops\_use\_collier}: Use Collier as the reduction
     method (default true).
 \end{itemize}
 
 %%%%%
 
 \subsubsection{Setting up \recola}
 \label{sec:recola-setup}
 
 The installation of \recola\ is explained in detail on the HepForge page
 \url{https://recola.hepforge.org}. In the following the main steps for
 usage with \whizard\ are summarized. The minimal required version number
 of \recola\ is 1.3.0.
 
 \recola\ can be linked to \whizard\ during configuration by including
 \begin{code}
   --enable-recola
 \end{code}
 In case the \recola\ library is not in a standard path or a path
 accessible in the \ttt{LD\_LIBRARY\_PATH} (or
 \ttt{DYLD\_LIBRARY\_PATH}) of the operating system, then the option
 \begin{code}
    --with-recola=$RECOLA_PATH
 \end{code}
 can be set, where \ttt{\$RECOLA\_PATH} is the directory the
 \recola\ library is located in. \recola\ can then be used with the
 \sindarin\ option
 \begin{code}
   $method = "recola"
 \end{code}
 or any other of the matrix element methods.
 
 Note that there might be a clash of the \collier\ libraries when you
 have \collier\ installed both via \recola\ and via \openloops, but
 have compiled them with different \fortran\ compilers.
 
 %%%%%
 
 \subsection{NLO cross sections}
 An NLO computation can be switched on in \sindarin\ with
 \begin{code}
   process proc_nlo = in1, in2 => out1, ..., outN { nlo_calculation = <components> },
 \end{code}
 where the \ttt{nlo\_calculation} can be followed by a list of strings
 specifying the desired NLO-components to be integrated, i.e.
 \ttt{born}, \ttt{real}, \ttt{virtual}, \ttt{dglap}, (for hadron
 collisions) or \ttt{mismatch} (for the soft mismatch in
 resonance-aware computations) and \ttt{full}. The \ttt{full} option
 switches on all components and is required if the total NLO result is
 desired. For example, specifying
 \begin{code}
   nlo_calculation = born, virtual
 \end{code}
 will result in the computation of the Born and virtual component.
 
 The integration can be carried out in two different modes: Combined
 and separate integration.  In the separate integration mode, each
 component is integrated individually, allowing for a good overview of
 their contributions to the total cross section and a fine tuned
 control over the iterations in each component.  In the combined
 integration mode, all components are added up during integration so that
 the sum of them is evaluated.  Here, only one integration will be
 displayed.  The default method is the separate integration.
 
 The convergence of the integration can crucially be influenced by the
 presence of resonances.  A better convergence is in this case achieved
 activating the resonance-aware FKS subtraction,
 \begin{code}
   $fks_method = "resonances".
 \end{code}
 This mode comes with an additional integration component, the
 so-called soft mismatch.
 
 Note that you can modify the number of iterations in each component with
 the multipliers:
 \begin{itemize}
   \item \ttt{mult\_call\_real} multiplies the number of calls to be used
     in the integration of the real component. A reasonable choice is
     \ttt{10.0} as the real phase-space is more complicated than the Born
     but the matrix elements evaluate faster than the virtuals.
   \item \ttt{mult\_call\_virt} multiplies the number of calls to be used
     in the integration of the virtual component. A reasonable choice is
     \ttt{0.5} to make sure that the fast Born component only contributes
     a negligible MC error compared to the real and virtual components.
   \item \ttt{mult\_call\_dglap} multiplies the number of calls to be used
     in the integration of the DGLAP component.
 \end{itemize}
 
 \subsection{Fixed-order NLO events}
 \label{ss:fixedorderNLOevents}
 Fixed-order NLO events can also be produced in three different modes:
 Combined weighted, combined unweighted and separated weighted.
 \begin{itemize}
   \item \textbf{Combined weighted}\\
     In the combined mode, one single integration grid is produced, from
     which events are generated with the total NLO weight. The
     corresponding event file contains $N$ events with born-like
     kinematics and weight equal to $\mathcal{B} + \mathcal{V} +
     \sum_{\alpha_r} \mathcal{C}_{\alpha_r}$, where $\mathcal{B}$ is the
     Born matrix element, $\mathcal{V}$ is the virtual matrix element and
     $\mathcal{C}_{\alpha_r}$ are the subtraction terms in each singular
     region. For resonance-aware processes, also the mismatch value is
     added. Each born-like event is followed by $N_{\text{phs}}$
     associated events with real kinematics, i.e. events where one
     additional QCD particle is present. The corresponding real
     matrix-elements $\mathcal{R}_\alpha$ form the weight of these events.
     $N_{\text{phs}}$ the number of distinct phase spaces. Two phase spaces
     are distinct if they share the same resonance history but have
     different emitters. So, two $\alpha_r$ can share the same phase
     space index.
 
     The combined event mode is activated by
     \begin{code}
       ?combined_nlo_integration = true
       ?unweighted = false
       ?fixed_order_nlo_events = true
     \end{code}
     Moreover, the process must be specified at next-to-leading-order in its
     definition using \ttt{nlo\_calculation = full}.  \whizard\ then
     proceeds as in the usual simulation mode. I.e. it first checks
     whether integration grids are already present and uses them if they
     fit. Otherwise, it starts an integration.
   \item \textbf{Combined unweighted}\\
     The unweighted combined events can be generated by using the
     \powheg\ mode, cf. also the next subsection, but disabling the
     additional radiation and Sudakov factors with the
     \ttt{?powheg\_disable\_sudakov} switch:
     \begin{code}
       ?combined_nlo_integration = true
       ?powheg_matching = true
       ?powheg_disable_sudakov = true
     \end{code}
     This will produce events with Born kinematics and unit weights (as
     \ttt{?unweighted} is \ttt{true} by default).  The events are
     unweighted by using $\mathcal{B} + \mathcal{V} + \sum_{\alpha_r}
     (\mathcal{C}_{\alpha_r} + \mathcal{R}_{\alpha_r})$.  Of course, this
     only works when these weights are positive over the full
     phase-space, which is not guaranteed for all scales and regions at
     NLO.  However, for many processes perturbation theory works nicely
     and this is not an issue.
 
   \item \textbf{Separate weighted}\\
     In the separate mode, grids and events are generated for each
     individual component of the NLO process. This method is preferable
     for complicated processes, since it allows to individually tune each
     grid generation. Moreover, the grid generation is then trivially
     parallelized.  The event files either contain only Born
     kinematics with weight $\mathcal{B}$ or $\mathcal{V}$ (and mismatch
     in case of a resonance-aware process) or mixed Born and real
     kinematics for the real component like in the combined mode.
     However, the Born events have only the weight $\sum_{\alpha_r}
     \mathcal{C}_{\alpha_r}$ in this case.
 
     The separate event mode is activated by
     \begin{code}
       ?unweighted = false
       ?negative_weights = true
       ?fixed_order_nlo_events = true
     \end{code}
     Note that negative weights have to be switched on because, in contrast
     to the combined mode, the total cross sections of the individual
     components can be negative.
 
     Also, the desired component has to appear in the process NLO
     specification, e.g. using \ttt{nlo\_calculation = real}.
 \end{itemize}
 Weighted fixed-order NLO events are supported by any output format that
 supports weights like the \ttt{HepMC} format and unweighted NLO events
 work with any format. The output can either be written to disk or put
 into a FIFO to interface it to an analysis program without writing
 events to file.
 
 The weights in the real event output, both in the combined and separate
 weighted mode, are divided by a factor $N_{\text{phs}} + 1$. This
 is to account for the fact that we artificially increase the number of
 events in the output file.  Thus, the sum of all event weights correctly
 reproduces the total cross section.
 
 \subsection{\powheg\ matching}
 To match the NLO computation with a parton shower, \whizard\ supports
 the  \powheg\ matching.  It generates a distribution according to
 \begin{align}
   \label{eq:powheg}
   \text{d}\sigma &= \text{d}\Phi_n \,{\bar{B}_{\text{s}}}\,\biggl(
   {\Delta_{\text{s}}}(p_T^{\text{min}}\bigr) +
   \text{d}\Phi_{\text{rad}}\,{\Delta_{\text{s}}}(k_{\text{T}}(\Phi_{\text{rad}})\bigr)
   {\frac{R_{\text{s}}}B}\biggr) \quad \text{where} \\
   {\bar{B}_{\text{s}}} &= {B} + {\mathcal{V}} + \text{d}\Phi_{\text{rad}}\,
     {\mathcal{R}_{\text{s}}} \quad \text{and} \\
   {\Delta_{\text{s}}}(p_T) &= \exp\left[- \int{\text{d}\Phi_{\text{rad}}}
    {\frac{R_{\text{s}}}{B}}\; \theta\left(k_T^2(\Phi_{\text{rad}}) -
    p_T^2\right)\right]\;.
 \end{align}
 The subscript s refers to the singular part of the real component, cf.
 to the next subsection.  Eq.~\eqref{eq:powheg} produces either no or one
 additional emission.  These events can then either be analyzed directly
 or passed on to the parton shower\footnote{E.g. \pythiaeight\ has
 explicit examples for \powheg\ input, see also
 \url{http://home.thep.lu.se/Pythia/pythia82html/POWHEGMerging.html}.}
 for the full simulation.  You activate this with
 \begin{code}
   ?fixed_order_nlo_events = false
   ?combined_nlo_integration = true
   ?powheg_matching = true
 \end{code}
 The $p_T^{\text{min}}$ of Eq.~\eqref{eq:powheg} can be set with
 \ttt{powheg\_pt\_min}.  It sets the minimal scale for the \powheg\
 evolution and should be of order 1 GeV and set accordingly in the
 interfaced shower.  The maximal scale is currently given by \ttt{sqrts}
 but should in the future be changeable with \ttt{powheg\_pt\_min}.
 
 Note that the \powheg\ event generation needs an additional grid for
 efficient event generation that is automatically generated during
 integration.  Further options that steer the efficiency of this grid are
 \ttt{powheg\_grid\_size\_xi} and \ttt{powheg\_grid\_size\_y}.
 
 \subsection{Separation of finite and singular contributions}
 
 For both the pure NLO computations as well as the \powheg\ event
 generation, \whizard\ supports the partitioning of the real into finite
 and singular contributions with the flag
 \begin{code}
   ?nlo_use_real_partition = true
 \end{code}
 The finite contributions, which by definition should not contain soft or
 collinear emissions, will then integrate like a ordinary LO integration
 with one additional particle.  Similarly, the event generation will
 produce only real events without subtraction terms with Born kinematics
 for this additional finite component.  The \powheg\ event generation
 will also only use the singular parts.
 
 The current implementation uses the following parametrization
 \begin{align}
   R                 &= R_{\text{fin}} + R_{\text{sing}} \;,\\
   R_{\text{sing}}     &= R F(\Phi_{n+1}) \;,\\
   R_{\text{fin}}      &= R (1-F(\Phi_{n+1})) \;,\\
   F(\Phi_{n+1})     &=
   \begin{cases}
     1 & \text{if} \quad\exists\,(i,j)\in\mathcal{P}_{\text{FKS}}\quad \text{with} \quad
       \sqrt{(p_i+p_j)^2} < h + m_i + m_j  \\
     0 & \text{else}
   \end{cases} \;.
 \end{align}
 Thus, a point is {singular ($F=1$)}, if {any} of the {FKS tuples}
 forms an {invariant mass} that is {smaller than the hardness scale
 $h$}. This parameter is controlled in \sindarin\ with
 \ttt{real\_partition\_scale}.
 This simplifies in {massless case} to
 \begin{align}
   F(\Phi_{n+1}) =
   \begin{cases}
     1 & \text{if} \;\exists\,(i,j)\in\mathcal{P}_{\text{FKS}}\quad \text{with} \quad
       2 E_i E_j (1-\cos\theta_{ij}) < h^2  \\
     0 & \text{else}
   \end{cases} \;.
 \end{align}
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \chapter{Random number generators}
 \label{chap:rng}
 
 \section{General remarks}
 \label{sec:rng}
 
 The random number generators (RNG) are one of the crucialer points of Monte
 Carlo calculations, hence, giving those their ``randomness''. A decent
 multipurpose random generator covers
 \begin{itemize}
 \item reproducibility
 \item large period
 \item fast generation
 \item independence
 \end{itemize}
 of the random numbers. Therefore, special care is taken for the choice of the
 RNGs in \whizard{}. It is stated that \whizard{} utilizes \textit{pseudo}-RNGs,
 which are based on one (or more) recursive algorithm(s) and start-seed(s) to have
 reproducible sequences of numbers. In contrast, a genuine random generator relies
 on physical processes.
 
 \whizard\ ships with two completely different random number generators which can be
 selected by setting the \sindarin\ option
 \begin{code}
   $rng_method = "rng_tao"
 \end{code}
 Altough, \whizard{} sets a default seed, it is adviced to use a different one
 \begin{code}
   seed = 175368842
 \end{code}
 note that some RNGs do not allow certain seed values (e.g. zero seed).
 
 \section{The TAO Random Number Generator}
 \label{sec:tao}
 
 The TAO (``The Art Of'') random number generator is a lagged Fibonacci
 generator based upon (signed) 32-bit integer arithmetic and was proposed by
 Donald E. Knuth and is implemented in the \vamp\ package.
 The TAO random number generator is the default RNG of \whizard{}, but can additionally
 be set as \sindarin\ option
 \begin{code}
   $rng_method = rng_tao
 \end{code}
 
 The TAO random number generators is a subtractive lagged Fibonacci generator
 \begin{equation*}
   x_{j} = \left( x_{j-k} - x_{j-L} \right) \mod 2^{30}
 \end{equation*}
 with lags $k = 100$ and $l = 37$ and period length $\rho = 2^{30} - 2$.
 
 \section{The RNGStream Generator}
 \label{sec:rngstream}
 
 The RNGStream \cite{L_Ecuyer:2002} was originally implemented in \cpp\ with
 floating point arithmetic and has been ported to \fortranOThree\. The RNGstream
 can be selected by the \sindarin\ option
 \begin{code}
   $rng_method = "rng_stream"
 \end{code}
 
 The RNGstream supports multiple independent streams and substreams of random
 numbers which can be directly accessed.
 
 The main advantage of the RNGStream lies in the domain of parallelization where
 different worker have to access different parts of the random number stream to
 ensure numerical reproducibility. The RNGstream provides exactly this property with its
 (sub)stream-driven model.
 
 Unfortunately, the RNGStream can only be used in combination with \vamptwo{}.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \chapter{Integration Methods}
 
 \section{The Monte-Carlo integration routine: \ttt{VAMP}}
 \label{sec:vamp}
 
 \vamp\ \cite{Ohl:1998jn}
 is a multichannel extension of the \vegas\ \cite{Lepage:1980dq}
 algorithm. For all possible singularities in the integrand, suitable
 maps and integration channels are chosen which are then weighted and
 superimposed to build the phase space parameterization. Both grids and
 weights are modified in the adaption phase of the integration.
 
 The multichannel integration algorithm is implemented as a
 \fortranNinetyFive\ library with the task of mapping out the integrand
 and finding suitable parameterizations being completely delegated to
 the calling program (\whizard\ core in this case). This makes the
 actual \vamp\ library completely agnostic of the model under
 consideration.
 
 \section{The next generation integrator: \ttt{VAMP2}}
 \label{sec:vamp2}
 
 \vamptwo\ is a modern implementation of the integrator package \vamp\ written
 in \fortranOThree\, providing the same features. The backbone integrator is
 still \vegas\ \cite{Lepage:1980dq}, although implemented differently as in
 \vamp{}.
 
 The main advantage over \vamp\ is the overall faster integration due to the usage
 of \fortranOThree{}, the possible usage of different random number generators
 and the complete parallelization of \vegas\ and the multichannel integration.
 
 \vamptwo{} can be set by the \sindarin{} option
 \begin{code}
   $integration_method = "vamp2"
 \end{code}
 
 It is said that the generated grids between \vamp{} and \vamptwo{} are
 incompatible.
 
 \subsection{Multichannel integration}
 \label{sec:multi-channel}
 
 The usual matrix elements do not factorise with respect to their integration
 variables, thus making an direct integration ansatz with VEGAS
 unfavorable.\footnote{One prerequisite for the VEGAS algorithm is that the
   integral factorises, and such produces only the best results for those.} Instead, we
 apply the multichannel ansatz and let VEGAS integrate each channel in a
 factorising mapping.
 
 The different structures of the matrix element are separated by a partition of
 unity and the respective mappings, such that each structure factorise at least
 once. We define the mappings $\phi_i : U \mapsto \Omega$, where $U$ is the unit
 hypercube and $\Omega$ the physical phase space. We refer to each mapping as a
 \textit{channel}. Each channel then gives rise to a probability density $g_i : U
 \mapsto [0, \infty)$, normalised to unity
 \begin{equation*}
   \int_0^1 g_i(\phi_i^{-1}(p)) \left| \frac{\partial \phi_i^{-1}}{\partial p} \right| \mathrm{d}\mu(p) = 1, \quad g_i(\phi_i^{-1}(p)) \geq 0,
 \end{equation*}
 written for a phase space point $p$ using the mapping $\phi_i$.
 The \textit{a-priori} channel weights $\alpha_i$ are defined as partition of
 unity by $\sum_{i\in I} \alpha_i = 1$ and $0 \leq \alpha_i \leq 1$. The overall
 probability density $g$ of a random sample is then obtained by
 \begin{equation*}
   g(p) = \sum_{i \in I} \alpha_i g_i(\phi_i^{-1}(p)) \left| \frac{\partial \phi_i^{-1}}{\partial p} \right|,
 \end{equation*}
 which is also a non-negative and normalized probability density.
 
 We reformulate the integral
 \begin{equation*}
   I(f) = \sum_{i \in I} \alpha_i \int_\Omega g_i(\phi_i^{-1}(p)) \left| \frac{\partial \phi_i^{-1}}{\partial p} \right| \frac{f(p)}{g(p)} \mathrm{d}\mu(p).
 \end{equation*}
 The actual integration of each channel is then done by VEGAS, which shapes the $g_i$.
 
 \subsection{VEGAS}
 \label{sec:vegas}
 
 VEGAS is an adaptive and iterative Monte Carlo algorithm for integration using
 importance sampling. After each iteration, VEGAS adapts the probability density
 $g_i$ using information collected while sampling. For independent
 integration variables, the probability density factorises $g_i = \prod_{j =
   1}^{d} g_{i,j}$ for each integration axis and each (independent) $g_{i,j}$ is
 defined by a normalised step function
 \begin{equation*}
   g_{i,j} (x_j) = \frac{1}{N\Delta x_{j,k}}, \quad x_{j,k} - \Delta x_{j,k} \leq x_{j} < x_{j,k},
 \end{equation*}
 where the steps are $0 = x_{j, 0} < \cdots < x_{j,k} < \cdots < x_{j,N} = 1$ for
 each dimension $j$.
 The algorithm randomly selects for each dimension a bin and a position inside
 the bin and calculates the respective $g_{i,j}$.
 
 \subsection{Channel equivalences}
 \label{sec:equivalences}
 
 The automated mulitchannel phasespace configuration can lead to a surplus of
 degrees of freedom, e.g. for a highly complex process with a large number of
 channels (VBS). In order to marginalize the redundant degrees of freedom of
 phasespace configuration, the adaptation distribution of the grids are aligned in accordance to their
 phasespace relation, hence the binning of the grids is equialized. These equivalences are activated by
 default for \vamp{} and \vamptwo{}, but can be steered by:
 
 \begin{code}
   ?use_vamp_equivalences = true
 \end{code}
 
 Be aware, that the usage of equivalences are currently only possible for LO
 processes.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \chapter{Phase space parameterizations}
 
 \section{General remarks}
 
 \whizard\ as a default performs an adaptive multi-channel Monte-Carlo
 integration. Besides its default phase space algorithm, \ttt{wood}, to
 be detailed in Sec.~\ref{sec:wood}, \whizard\ contains a phase space
 method \ttt{phs\_none} which is a dummy method that is intended for
 setups of processes where no phase space integration is needed, but
 the program flow needs a (dummy) integrator for internal
 consistency. Then, for testing purposes, there is a single-channel
 phase space integrator, \ttt{phs\_single}. From version 2.6.0 of
 \whizard\ on, there is also a second implementation of the \ttt{wood}
 phase space algorithm, called \ttt{fast\_wood},
 cf. Sec.~\ref{sec:fast_wood}, whose implementation differs technically
 and which therefore solves certain technical flaws of the \ttt{wood}
 implementation. 
 
 \section{The default method: \ttt{wood}}
 \label{sec:wood}
 
 The \ttt{wood} algorithm classifies different phase space channels
 according to their importance for a full scattering or decay process
 following heuristic rules. For that purpose, \whizard\ investigates
 the kinematics of the different channels depending on the total
 center-of-mass energy (or the mass of the decaying particle) and the
 masses of the final-state particles.
 
 The \ttt{wood} phase space inherits its name from the naming schemes
 of structures of increasing complexities, namely trees, forests and
 groves. Simply stated, a phase-space forest is a collection of
 phase-space trees. A phase-space tree is a parameterization for a
 valid channel in the multi-channel adaptive integration, and each
 variable in the a tree corresponds to an integration dimension,
 defined by an appropriate mapping of the $(0,1)$ interval of the unit
 hypercube to the allowed range of the corresponding integration
 variable. The whole set of these phase-space trees, collected in a
 phase-space forest object hence contains all parameterizations of the
 phase space that \whizard\ will use for a single hard process. Note
 that processes might contain flavor sums of particles in the final
 state. As \whizard\ will use the same phase space parameterization for
 all channels for this set of subprocesses, all particles in those
 flavor sums have to have the same mass. E.g. in the definition of a
 "light" jet consisting of the first five quarks and antiquarks,
 \begin{code}
   alias jet = u:d:s:c:b:U:D:S:C:B
 \end{code}
 all quarks including strange, charm and bottom have to be massless for
 the phase-space integration. \whizard\ can treat processes with
 subprocesses having final-state particles with different masses in an
 "additive" way, where each subprocess will become a distinct component
 of the whole process. Each process component will get its own
 phase-space parameterization, such that they can allow for different
 masses. E.g. in a 4-flavor scheme for massless $u,d,s,c$ quarks one
 can write
 \begin{code}
   alias jet = u:d:s:c:U:D:S:C
   process eeqq = e1, E1 => (jet, jet) + (b, B)
 \end{code}
 In that case, the parameterizations will be for massless final state
 quarks for the first subprocess, and for massive $b$ quarks for the
 second subprocess. In general, for high-energy lepton colliders, the
 difference would not matter much, but performing the integration
 e.g. for $\sqrt{s} = 11$ GeV, the difference will be
 tremendous. \whizard\ avoids inconsistent phase-space
 parameterizations in that way.
 
 As a multi-particle process will contain hundred or thousands of
 different channels, the different integration channels (trees) are
 grouped into so called {\em groves}. All channels/trees in the same
 grove share a common weight for the phase-space integration, following
 the assumption that they are related by some approximate symmetry. The
 \vamp\ adaptive multi-channel integrator (cf. Sec.~\ref{sec:vamp})
 allows for equivalences between different integration channels. This
 means that trees/channels that are related by an exact symmetry are
 connected by an array of these equivalences.
 
 The phase-space setup, i.e. the detailed structure of trees and
 forests, are written by \whizard\ into a phase-space file that has the
 same name as the corresponding process (or process component) with the
 suffix \ttt{.phs}. For the \ttt{wood} phase-space method this file is
 written by a \fortran\ module which constructs a similar tree-like
 structure as the directed acyclical graphs (DAGs) in the
 \oMega\ matrix element generator but in a less efficient way. 
 
 In some very rare cases with externally generated models
 (cf. Chapter~\ref{chap:extmodels}) the phase-space generation has been
 reported to fail as \whizard\ could not find a valid phase-space
 channel. Such pathological cases cannot occur for the hard-coded model
 implementations inside \whizard. They can only happen if there are in
 principle two different Feynman diagrams contributing to the same
 phase-space channel and \whizard\ considers the second one as
 extremely subleading (and would hence drop it). If for some reason
 however the first Feynman diagram is then absent, no phase-space
 channel could be found. This problem cannot occur with the
 \ttt{fast\_wood} implementation discussed in the next section,
 cf.~\ref{sec:fast_wood}.
 
 The \ttt{wood} algorithms orders the different groves of phase-space
 channels according to a heuristic importance depending on the
 kinematic properties of the different phase-space channels in the
 groves. A phase-space (\ttt{.phs}) file looks typically like this:
 \begin{code}
  process sm_i1
 
 ! List of subprocesses with particle bincodes:
 !  8  4      1   2
 ! e+ e- => mu+ mu-
 !  8  4      1   2
 
    md5sum_process    = "1B3B7A30C24664A73D3D027382CFB4EF"
    md5sum_model_par  = "7656C90A0B2C4325AD911301DACF50EB"
    md5sum_phs_config = "6F72D447E8960F50FDE4AE590AD7044B"
    sqrts         =  1.000000000000E+02
    m_threshold_s =  5.000000000000E+01
    m_threshold_t =  1.000000000000E+02
    off_shell = 2
    t_channel = 6
    keep_nonresonant = T
 
  ! Multiplicity = 2, no resonances,  0 logs,  0 off-shell,  s-channel graph
  grove #1
  ! Channel #1
    tree  3
 
  ! Multiplicity = 1, 1 resonance,   0 logs,  0 off-shell,  s-channel graph
  grove #2
  ! Channel #2
    tree  3
    map   3 s_channel      23 ! Z  
 \end{code}
 The first line contains the process name, followed by a list of
 subprocesses with the external particles and their binary codes. Then
 there are three lines of MD5 check sums, used for consistency
 checks. \whizard\ (unless told otherwise) will check for the existence
 of a phase-space file, and if the check sum matches, it will reuse the
 existing file and not generate it again. Next, there are several
 kinematic parameters, namely the center-of-mass energy of the process,
 \ttt{sqrts}, and two mass thresholds, \ttt{m\_threshold\_s} and
 \ttt{m\_threshold\_t}. The latter two are kinematical thresholds,
 below which \whizard\ will consider $s$-channel and $t$-channel-like
 kinematic configurations as effectively massless, respectively. The
 default values shown in the example have turned out to be optimal
 values for Standard Model particles. The two integers \ttt{off\_shell}
 and \ttt{t\_channel} give the number of off-shell lines and of
 $t$-channel lines that \whizard\ will allow for finding valid
 phase-space channels, respectively. This neglects extremley multi-peripheral
 background-like diagram constellations which are very subdominamnt
 compared to resonant signal processes. The final flags specifies
 whether \whizard\ will keep non-resonant phase-space channels
 (default), or whether it will focus only on resonant situations.
 
 After this header, there is a list of all groves, i.e. collections of
 phase-space channels which are connected by quasi-symmetries, together
 with the corresponding multiplicity of subchannels in that
 grove. In the phase-space file, Behind the multiplicity
 \whizard\ denotes the number of (massive) resonances, logarithmcally
 enhanced kinematics (e.g. collinear regions), and number of off-shell
 lines, respectively. The final entry in the grove header notifies
 whether the diagrams in that grove have $s$-channel topologies, or
 count the number of corresponding $t$-channel lines.
 
 Another example is shown here,
 \begin{code}
  ! Multiplicity = 3, no resonances,  2 logs,  0 off-shell,  1 t-channel line
  grove #1
  ! Channel #1
    tree  3 12
    map   3 infrared       22 ! A
    map  12 t_channel       2 ! u
  ! Channel #2
    tree  3 11
    map   3 infrared       22 ! A
    map  11 t_channel       2 ! u
  ! Channel #3
    tree  3 20
    map   3 infrared       22 ! A
    map  20 t_channel       2 ! u
  ! Channel #4
    tree  3 19
    map   3 infrared       22 ! A
    map  19 t_channel       2 ! u  
 \end{code}
 where \whizard\ notifies in different situations a photon exchange as
 \ttt{infrared}. So it detects a possible infrared singularity where a
 particle can become arbitrarily soft. Such a situation can tell the
 user that there might be a cut necessary in order to get a meaningful
 integration result. 
 
 The phase-space setup that is generated and used by the \ttt{wood}
 phase-space method can be visualized using the \sindarin\ option
 \begin{code}
   ?vis_channels = true
 \end{code}
 
 The \ttt{wood} phase-space method can be invoked with the
 \sindarin\ command
 \begin{code}
   $phs_method = "wood"
 \end{code}
 Note that this line is unnecessary, as \ttt{wood} is the default
 phase-space method of \whizard.
 
 %%%%%
 
 \section{A new method: \ttt{fast\_wood}}
 \label{sec:fast_wood}
 
 This method (which is available from version 2.6.0 on) is an
 alternative implementation of the \ttt{wood} phase-space algorithm. It
 uses the recursive structures inside the \oMega\ matrix element
 generator to generate all the structures needed for the different
 phase-space channels. In that way, it can avoid some of the
 bottlenecks of the \ttt{wood} \fortran\ implementation of the
 algorithm. On the other hand, it is only available if the
 \oMega\ matrix element generator has been enabled (which is the
 default for \whizard). The \ttt{fast\_wood} method is then invoked via
 \begin{code}
   ?omega_write_phs_output = true
   $phs_method = "fast_wood"
 \end{code}
 The first option is necessary in order to tell \oMega\ to write out
 the output needed for the \ttt{fast\_wood} parser in order to generate
 the phase-space file. This is not enabled by default in order not to
 generate unnecessary files in case the default method \ttt{wood} is
 used.
 
 So the \ttt{fast\_wood} implementation of the \ttt{wood} phase-space
 algorithm parses the tree-like represenation of the recursive set of
 one-particle off-shell wave functions that make up the whole amplitude
 inside \oMega\ in the form of a directed acyclical graph (DAG) in
 order to generate the phase-space (\ttt{.phs}) file
 (cf. Sec.~\ref{sec:wood}). In that way, the algorithm makes sure that
 only phase-space channels are generated for which there are indeed
 (sub)amplitudes in the matrix elements, and this also allows to
 exclude vetoed channels due to restrictions imposed on the matrix
 elements from the phase-space setup (cf. next
 Sec.~\ref{sec:ps_restrictions}.
 
 %%%%%
 
 \section{Phase space respecting restrictions on subdiagrams}
 \label{sec:ps_restrictions}
 
 The \fortran\ implementation of the \ttt{wood} phase-space does not
 know anything about possible restrictions that maybe imposed on the
 \oMega\ matrix elements, cf. Sec.~\ref{sec:process options}.
 Consequently, the \ttt{wood} phase space also generates phase-space
 channels that might be absent when restrictions are imposed. This is
 not a principal problem, as in the adaptation of the phase-space
 channels \whizard's integrator \vamp\ will recognize that there is
 zero weight in that channel and will drop the channel (stop sampling
 in that channel) after some iterations. However, this is a waste of
 ressources as it is in principle known that this channel is
 absent. Using the \ttt{fast\_wood} phase-space algorithm
 (cf. Sec.~\ref{sec:fast_wood} will take restrictions into account, as
 \oMega\ will not generate trees for channels that are removed with the
 restrictions command. So it advisable for the user in the case of very
 complicated processes with restrictions to use the \ttt{fast\_wood}
 phase-space method to make \whizard\ generation and integration of the
 phase space less cumbersome. 
 
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \chapter{Methods for Hard Interactions}
 \label{chap:hardint}
 
 The hard interaction process is the core of any physics simulation
 within an MC event generator. One tries to describe the dominant
 particle interaction in the physics process of interest at a given
 order in perturbation theory, thereby making use of field-theoretic
 factorization theorems, especially for QCD, in order to separate
 non-perturbative physics like parton distribution functions (PDFs) or
 fragmentation functions from the perturbative part. Still, it is in
 many cases not possible to describe the perturbative part completely
 by means of fixed-order hard matrix elements: in soft and/or collinear
 regions of phase space, multiple emission of gluons and quarks (in
 general QCD jets) and photons necessitates a resummation, as large
 logarithms accompany the perturbative coupling constants and render
 fixed-order perturbation theory unreliable. The resummation of these
 large logarithms can be done analytically or (semi-)numerically,
 however, usually only for very inclusive quantities. At the level of
 exclusive events, these phase space regions are the realm of (QCD and
 also QED) parton showers that approximate multi-leg matrix elements
 from the hard perturbative into to the soft-/collinear regime. 
 
 The hard matrix elements are then the core building blocks of the
 physics description inside the MC event generator. \whizard\ generates
 these hard matrix elements at tree-level (or sometimes for
 loop-induced processes using effective operators as insertions) as
 leading-order processes. This is done by the \oMega\ subpackage that
 is automatically called by \whizard. Besides these physical matrix
 elements, there exist a couple of methods to generate dummy matrix
 elements for testing purposes, or for generating beam profiles and
 using them with externally linked special matrix elements. 
 
 Especially for one-loop processes (next-to-leading order for
 tree-allowed processes or leading-order for loop-induced processes),
 \whizard\ allows to use matrix elements from external providers, so
 called OLP programs (one-loop providers). Of course, all of these
 external packages can also generate tree-level matrix elements, which
 can then be used as well in \whizard. 
 
 We start the discussion with the two different options for test matrix
 elements, internal test matrix elements with no generated compiled code
 in Sec.~\ref{sec:unit_me} and so called template matrix elements with
 actual \fortran\ code that is compiled and linked, and can also be
 modified by the user in Sec.~\ref{sec:template_me}. Then, we move to
 the main matrix element method by the matrix element generator
 \oMega\ in Sec.~\ref{sec:omega_me}. Matrix elements from the external
 matrix element generators are discussed in the order of which
 interfaces for the external tools have been implemented: \gosam\ in
 Sec.~\ref{sec:gosam_me}, \openloops\ in Sec.~\ref{sec:openloops_me},
 and \recola\ in Sec.~\ref{sec:recola_me}.
 
 %%%%%
 
 \section{Internal test matrix elements}
 \label{sec:test_me}
 
 This method is merely for internal consistency checks inside \whizard,
 and is not really intended to be utilized by the user. The method is
 invoked by
 \begin{code}
   $method = "unit_test"
 \end{code}
 This particular method is only applicable for the internal test model
 \ttt{Test.mdl}, which just contains a Higgs boson and a top
 quark. Technically, it will also works within model specifications
 for the Standard Model, or the Minimal Supersymmetric Standard Model
 (MSSM), or all models which contain particles named as \ttt{H} and
 \ttt{t} with PDG codes 25 and 6, respectively. So, the models
 \ttt{QED} and {QCD} will not work. Irrespective of what is given in
 the \sindarin\ file as a scattering input process, \whizard\ will
 always take the process 
 \begin{code}
   model = SM
   process <proc_name>= H, H => H, H
 \end{code}
 or for the test model:
 \begin{code}
   model = Test
   process <proc_name>= s, s => s, s
 \end{code}
 as corresponding process. (This is the same process, just with
 differing nomenclature in the different models). No matrix element
 code is generated and compiled, the matrix element is completely
 internal, included in the \whizard\ executable (or library), with a
 unit value for the squared amplitude. The integration will always be
 performed for this particularly process, even if the user provides a
 different process for that method. Hence, the result will always be
 the volume of the relativistic two-particle phase space. The only two
 parameters that influence the result are the collider energy,
 \ttt{sqrts}, and the mass of the Higgs particle with PDG code 25 (this
 mass parameter can be changed in the model \ttt{Test} as \ttt{ms},
 while it would be \ttt{mH} in the Standard Model \ttt{SM}. 
 
 It is also possible to use a test matrix element, again internal, for
 decay processes, where again \whizard\ will take a predefined process:
 \begin{code}
   model = SM
   process <proc_name> = H => t, tbar
 \end{code}
 in the \ttt{SM} model or 
 \begin{code}
   model = Test
   process <proc_name> = s => f, fbar
 \end{code}
 Again, this is the same process with PDG codes $25 \to 6 \; -6$ in the
 corresponding models. Note that in the model \ttt{SM} the mass of the
 quark is set via the variable \ttt{mtop}, while it is \ttt{mf} in the
 model \ttt{Test}. 
 
 Besides the fact that the user always gets a fixed process and cannot
 modify any matrix element code by hand, one can do all things as for a
 normal process like generating events, different weights, testing
 rebuild flags, using different setups and reweight events
 accordingly. Also factorized processes with production and decay can
 be tested that way. 
 
 In order to avoid confusion, it is highly recommended to use this
 method \ttt{unit\_test} only with the test model setup, model
 \ttt{Test}.
 
 On the technical side, the method \ttt{unit\_test} does not produce a
 process library (at least not an externally linked one), and also not
 a makefile in order to modify any process files (which anyways do not
 exist for that method). Except for the logfiles and the phase space
 file, all files are internal.
 
 %%%%%
 
 \section{Template matrix elements}
 \label{sec:template_me}
 
 Much more versatile for the user than the previous matrix element
 method in~\ref{sec:test_me}, are two different methods with constant
 template matrix elements. These are written out as \fortran\ code by
 the \whizard\ main executable (or library), providing an interface
 that is (almost) identical to the matrix element code produced by the
 \oMega\ generator (cf. the next section,
 Sec.~\ref{sec:omega_me}. There are actually two different methods for
 that purpose, providing matrix elements with different normalizations: 
 \begin{code}
   $method = "template"
 \end{code}
 generates matrix elements which give after integration over phase
 space exactly one. Of course, for multi-particle final states the
 integration can fluctuate numerically and could then give numbers that
 are only close to one but not exactly one. Furthermore, the
 normalization is not exact if any of the external particles have
 non-zero masses, or there are any cuts involved. But otherwise, the
 integral from \whizard\ should give unity irrespective of the number
 of final state particles. 
 
 In contrast to this, the second method,
 \begin{code}
   $method = "template_unity"
 \end{code}
 gives a unit matrix elements, or rather a matrix element that contains
 helicity and color averaging factors for the initial state and the
 square root of the factorials of identical final state particles in
 the denominator. Hence, integration over the final state momentum
 configuration gives a cross section that corresponds to the volume of
 the $n$-particle final state phase space, divided by the corresponding
 flux factor, resulting in
 \begin{equation}
   \sigma(s, 2 \to 2,0) = \frac{3.8937966\cdot 10^{11}}{16\pi} \cdot
   \frac{1}{s \text{[GeV]}^2} \; \text{fb}
 \end{equation}
 for the massless case and 
 \begin{equation}
   \sigma(s, 2 \to 2,m_i) = \frac{3.8937966\cdot 10^{11}}{16\pi} \cdot
   \sqrt{\frac{\lambda (s,m_3^2,m_4^2)}{\lambda (s,m_1^2,m_2^2)}}
   \cdot \frac{1}{s \text{[GeV]}^2} \; \text{fb} 
 \end{equation}
 for the massive case. Here, $m_1$ and $m_2$ are the masses of the
 incoming, $m_3$ and $m_4$ the masses of the outgoing particles, and
 $\lambda(x,y,z) = x^2 + y^2 + z^2 - 2xy - 2xz - 2yz$. 
 
 For the general massless case with no cuts, the integral should be
 exactly 
 \begin{equation}
   \sigma(s, 2\to n, 0) = \frac{(2\pi)^4}{2 s}\Phi_n(s)
   = \frac{1}{16\pi s}\,\frac{\Phi_n(s)}{\Phi_2(s)},
 \end{equation}
 where the volume of the massless $n$-particle phase space is
 given by
 \begin{equation}\label{phi-n}
   \Phi_n(s) = \frac{1}{4(2\pi)^5} \left(\frac{s}{16\pi^2}\right)^{n-2}
   \frac{1}{(n-1)!(n-2)!}.
 \end{equation} 
 For $n\neq2$ the phase space volume is dimensionful, so the
 units of the integral are $\fb\times\GeV^{2(n-2)}$. (Note that for
 physical matrix elements this is compensated by momentum factors from
 wave functions, propagators, vertices and possibly dimensionful
 coupling constants, but here the matrix element is just equal to
 unity.) 
 
 Note that the phase-space integration for the \ttt{template} and
 \ttt{template\_unity} matrix element methods is organized in the same
 way as it would be for the real $2\to n$ process.  Since such a phase
 space parameterization is not optimized for the constant matrix
 element that is supplied instead, good convergence is not guaranteed.
 (Setting \ttt{?stratified = true} may be helpful here.)
 
 The possibility to call a dummy matrix element with this method allows
 to histogram spectra or structure functions: Choose a trivial process
 such as $uu\to dd$, select the \ttt{template\_unity} method, switch
 on structure functions for one (or both) beams, and generate events.
 The distribution of the final-state mass squared reflects the $x$
 dependence of the selected structure function.
 
 Furthermore, the constant in the source code of the unit matrix
 elements can be easily modified by the user with their \fortran\ code
 in order to study customized matrix elements. Just rerun
 \whizard\ with the \ttt{--recompile} option after the modification of
 the matrix element code.
 
 Both methods, \ttt{template} and \ttt{template\_unity} will also work
 even if no \ocaml\ compiler is found or used and consequently the
 \oMega\ matrix elemente generator (cf. Sec.~\ref{sec:omega_me} is
 disable. The methods produce a process library for their corresponding
 processes, and a makefile, by  which \whizard\ steers compilation and
 linking of the process source code. 
 
 %%%%%
 
 \section{The O'Mega matrix elements}
 \label{sec:omega_me}
 
 \oMega\ is a subpackage of \whizard, written in \ocaml, which can
 produce matrix elements for a wide class of implemented physics models
 (cf. Sec.~\ref{sec:smandfriends} and \ref{sec:bsmmodels} for a list of
 all implemented physics models), and even almost arbitrary models when
 using external Lagrange level tools, cf. Chap.~\ref{chap:extmodels}.
 There are two different variants for matrix elements from \oMega:
 the first one is invoked as
 \begin{code}
   $method = "omega"
 \end{code}
 and is the default method for \whizard. It produces matrix element as
 \fortran\ code which is then compiled and linked. An alternative
 method, which for the moment is only available for the Standard Model
 and its variants as well models which are quite similar to the SM,
 e.g. the Two-Higgs doublet model or the Higgs-singlet extension. This
 method is taken when setting
 \begin{code}
   $method = "ovm"
 \end{code}
 The acronym \ttt{ovm} stands for \oMega\ Virtual Machine (OVM). The
 first (default) method (\ttt{omega}) of \oMega\ matrix elements
 produces \fortran\ code for the matrix elements,that is compiled by
 the same compiler with which \whizard\ has been compiled. The OVM
 method (\ttt{ovm}) generates an \ttt{ASCII} file with so called op
 code for operations. These are just numbers which tell what numerical
 operations are to be performed on momenta, wave functions and vertex
 expression in order to yield a complex number for the amplitude. The
 op codes are interpreted by the OVM in the same as a Java Virtual
 Machine. In both cases, a compiled \fortran\ is generated which for
 the \ttt{omega} method contains the full expression for the matrix
 element as \fortran\ code, while for the \ttt{ovm} method this is the
 driver file of the OVM. Hence, for the \ttt{ovm} method this file
 always has roughly the same size irrespective of the complexity of the
 process. For the \ttt{ovm} method, there will also be the \ttt{ASCII}
 file that contains the op codes, which has a name with an \ttt{.hbc}
 suffix: \ttt{<process\_name>.hbc}.
 
 For both \oMega\ methods, there will be a process library created as
 for the template matrix elements (cf. Sec.~\ref{sec:template_me})
 named \ttt{default\_lib.f90} which can be given a user-defined name
 using the \ttt{library = "<library>"} command. Again, for both methods
 \ttt{omega} and \ttt{ovm}, a makefile named
 \ttt{<library>\_lib.makefile} is generated by which \whizard\ steers
 compilation, linking and clean-up of the process sources. This
 makefile can handily be adapted by the user in case she or he wants to
 modify the source code for the process (in the case of the source code
 method).
 
 Note that \whizard's default ME method via \oMega\ allows the user to
 specify many different options either globally for all processes in
 the \sindarin, or locally for each process separately in curly
 brackets behind the corresponding process definition. Examples are
 \begin{itemize}
 \item
   Restrictions for the matrix elements like the exclusion of
   intermediate resonances, the appearance of specific vertices or
   coupling constants in the matrix elments. For more details on this
   cf. Sec.~\ref{subsec:restrictions}.
 \item
   Choice of a specific scheme for the width of massive intermediate
   resonances, whether to use constant width, widths only in
   $s$-channel like kinematics (this is the default), a fudged-width
   scheme or the complex-mass scheme. The latter is actually steered as
   a specific scheme of the underlying model and not with a specific
   \oMega\ command.
 \item
   Choice of the electroweak gauge for the amplitude. The default is
   the unitary gauge.
 \end{itemize}
 With the exception of the restrictions steered by the
 \ttt{\$restrictions = "<restriction>"} string expression, these options
 have to be set in their specific \oMega\ syntax verbatim via the
 string command \ttt{\$omega\_flags = "<expr>"}. 
 
 
 
 %%%%%
 
 \section{Interface to GoSam}
 \label{sec:gosam_me}
 
 One of the supported methods for automated matrix elements from
 external providers is for the \gosam\ package. This program package
 which is a combination of \python\ scripts and \fortran\ libraries,
 allows both for tree and one-loop matrix elements (which is leading or
 next-to-leading order, depending on whether the corresponding process
 is allowed at the tree level or not). In principle, the advanced
 version of \gosam\ also allows for the evaluation of two-loop virtual
 matrix elements, however, this is currently not supported in
 \whizard. This method is invoked via the command
 \begin{code}
   $method = "gosam"
 \end{code}
 Of course, this will only work correctly of \gosam\ with all its
 subcomponents has been correctly found during configuration of
 \whizard\ and then subsequently correctly linked.
 
 In order to generate the tables for spin, flavor and color states for 
 the  corresponding process, first \oMega\ is called to provide
 \fortran\ code for the interfaces to all the metadata for the
 process(es) to be evaluated. Next, the \gosam\ \python\ script is
 automatically invoked that first checks for the necessary ingredients
 to produce, compile and link the \gosam\ matrix elements. These are
 the the \ttt{Qgraf} topology generator for the diagrams, \ttt{Form} to
 perform algebra, the \ttt{Samurai}, \ttt{AVHLoop}, \ttt{QCDLoop} and
 \ttt{Ninja} libraries for Passarino-Veltman reduction, one-loop tensor
 integrals etc. As a next step, \gosam\ automatically writes and
 executes a \ttt{configure} script, and then it exchanges the Binoth
 Les Houches accord (BLHA) contract files between \whizard\ and
 itself~\cite{Binoth:2010xt,Alioli:2013nda} to check whether it
 actually generate code for the demanded process at the given
 order. Note that the contract and answer files do not have to be
 written by the user by hand, but are generated automatically within
 the program work flow initiated by the original
 \sindarin\ script. \gosam\ then generates \fortran\ code for the
 different components of the processes, compiles it and links it into a
 library, which is then automatically accessible (as an external
 process library) from inside \whizard. The phase space setup and the
 integration as well as the LO (and NLO) event generation work then in
 exactly the same way as for \oMega\ matrix elements.
 
 As an NLO calculation consists of different components for the Born,
 the real correction, the virtual correction, the subtraction part and
 possible further components depending on the details of the
 calculation, there is the possible to separately choose the matrix
 element method for those components via the keywords
 \ttt{\$loop\_me\_method}, \ttt{\$real\_tree\_me\_method},
 \ttt{\$correlation\_me\_method}  etc. These
 keywords overwrite the master switch of the \ttt{\$method} keyword. 
 
 For more information on the switches and details of the functionality
 of \gosam, cf. \url{http://gosam.hepforge.org}. 
 
 %%%%%
 
 \section{Interface to Openloops}
 \label{sec:openloops_me}
 
 Very similar to the case of \gosam, cf. Sec.~\ref{sec:gosam_me}, is
 the case for \openloops\ matrix elements. Also here, first \oMega\ is
 called in order to provide an interface for the spin, flavor and color
 degrees of freedom for the corresponding process. Information exchange
 between \whizard\ and \openloops\ then works in the same automatic way
 as for \gosam\ via the BLHA interface. This matrix element method is
 invoked via
 \begin{code}  
   $method = "openloops"
 \end{code}
 This again is the master switch that will tell \whizard\ to use
 \openloops\ for all components, while there are special keywords to
 tailor-make the setup for the different components of an NLO
 calculation (cf. Sec.~\ref{sec:gosam_me}.
 
 The main difference between \openloops\ and \gosam\ is that for
 \openloops\ there is no process code to be generated, compiled and
 linked for a process, but a precompiled library is called and linked,
 e.g. \ttt{ppll} for the Drell-Yan process. Of course, this library has
 to be installed on the system, but if that is not the case, the user
 can execute the \openloops\ script in the source directory of
 \openloops\ to download, compile and link the corresponding dynamic
 library. This limits (for the moment) the usage of \openloops\ to
 processes where pre-existint libraries for that specific processes
 have been generated by the \openloops\ authors. A new improved
 generator for general process libraries for \openloops\ will get rid
 of that restriction.
 
 For more information on the installation, switches and details of the
 functionality of \openloops, cf. \url{http://openloops.hepforge.org}. 
 
 %%%%%
 
 \section{Interface to Recola}
 \label{sec:recola_me}
 
 The third one-loop provider (OLP) for external matrix elements that
 is supported by \whizard, is \recola. In contrast to \gosam,
 cf. Sec.~\ref{sec:gosam_me}, and \openloops,
 cf. Sec.~\ref{sec:openloops_me}, \recola\ does not use a BLHA
 interface to exchange information with \whizard, but its own
 tailor-made C interoperable library interface to communicate to the
 Monte Carlo side. \recola\ matrix elements are called for via
 \begin{code}
   $method = "recola"
 \end{code}
 \recola\ uses a highly efficient algorithm to generate process code
 for LO and NLO SM amplitudes in a fully recursive manner. At the
 moment, the setup of the interface within \whizard\ does not allow to
 invoke more than one different process in \recola: this would lead to
 a repeated initialization of the main setup of \recola\ and would
 consequently crash it. It is foreseen in the future to have a
 safeguard mechanism inside \whizard\ in order to guarantee
 initialization of \recola\ only once, but this is not yet
 implemented.
 
 Further information on the installation, details and parameters of
 \recola\ can be found at \url{http://recola.hepforge.org}.
 
 %%%%%
 
 \section{Special applications}
 \label{sec:special_me}
 
 There are also special applications with combinations of matrix
 elements from different sources for dedicated purposes like e.g. for
 the matched top--anti-top threshold in $e^+e^-$. For this special
 application which depending on the order of the matching takes only
 \oMega\ matrix elements or at NLO combines amplitudes from \oMega\ and
 \openloops, is invoked by the method:
 \begin{code}
   $method = "threshold"
 \end{code}
 
 
 \newpage
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \chapter{Implemented physics}
 \label{chap:physics}
 
 %%%%%
 
 \section{The hard interaction models}
 
 In this section, we give a brief overview over the different
 incarnations of models for the description of the realm of subatomic
 particles and their interactions inside \whizard. In
 Sec.~\ref{sec:smandfriends}, the Standard Model (SM) itself and
 straightforward extensions and modifications thereof in the gauge,
 fermionic and Higgs sector are described. Then,
 Sec.~\ref{sec:bsmmodels} gives a list and short description of all
 genuine beyond the SM models (BSM) that are currently implemented in
 \whizard\ and its matrix element generator \oMega. Additional models
 beyond that can be integrated and handled via the interfaces to
 external tools like \sarah\ and \FeynRules, or the universal model
 format \UFO, cf. Chap.~\ref{chap:extmodels}.
 
 %%%%%%%%%%%%%%%
 
 \subsection{The Standard Model and friends}
 \label{sec:smandfriends}
 
 
 %%%%
 
 \subsection{Beyond the Standard Model}
 \label{sec:bsmmodels}
 
 \begin{table}
         \begin{center}
            \begin{tabular}{|l|l|l|}
              \hline
              MODEL TYPE & with CKM matrix & trivial CKM \\
              \hline\hline
              Yukawa test model & \tt{---} & \tt{Test} \\
              \hline
              QED with $e,\mu,\tau,\gamma$ & \tt{---} &  \tt{QED} \\
              QCD with $d,u,s,c,b,t,g$ & \tt{---} &  \tt{QCD} \\
              Standard Model        & \tt{SM\_CKM} & \tt{SM} \\
              SM with anomalous gauge couplings &  \tt{SM\_ac\_CKM} &
              \tt{SM\_ac} \\
              SM with $Hgg$, $H\gamma\gamma$, $H\mu\mu$, $He^+e^-$ &
              \tt{SM\_Higgs\_CKM} & \tt{SM\_Higgs} \\
              SM with bosonic dim-6 operators &  \tt{---} &
              \tt{SM\_dim6} \\
              SM with charge 4/3 top &  \tt{---} &
              \tt{SM\_top} \\
              SM with anomalous top couplings &  \tt{---} &
              \tt{SM\_top\_anom} \\
              SM with anomalous Higgs couplings &  \tt{---} &
              \tt{SM\_rx}/\tt{NoH\_rx}/\tt{SM\_ul} \\\hline
              SM extensions for $VV$ scattering & \tt{---} &
              \tt{SSC}/\tt{AltH}/\tt{SSC\_2}/\tt{SSC\_AltT} \\\hline
              SM with $Z'$ & \tt{---} & \tt{Zprime} \\
              \hline
              Two-Higgs Doublet Model & \tt{THDM\_CKM} & \tt{THDM} \\ \hline\hline
              MSSM &   \tt{MSSM\_CKM} & \tt{MSSM} \\
              \hline
              MSSM with gravitinos &   \tt{---} & \tt{MSSM\_Grav} \\
              \hline
              NMSSM &   \tt{NMSSM\_CKM} & \tt{NMSSM} \\
              \hline
              extended SUSY models &   \tt{---} & \tt{PSSSM} \\
              \hline\hline
              Littlest Higgs &  \tt{---} & \tt{Littlest} \\
              \hline
              Littlest Higgs with ungauged $U(1)$ &  \tt{---} &
              \tt{Littlest\_Eta} \\
              \hline
              Littlest Higgs with $T$ parity &  \tt{---} &
              \tt{Littlest\_Tpar} \\
              \hline
              Simplest Little Higgs (anomaly-free) &  \tt{---} &
              \tt{Simplest} \\
              \hline
              Simplest Little Higgs (universal) &  \tt{---} &
              \tt{Simplest\_univ} \\
              \hline\hline
              SM with graviton & \tt{---} & \tt{Xdim} \\
              \hline
              UED & \tt{---} & \tt{UED} \\
              \hline
              ``SQED'' with gravitino & \tt{---} & \tt{GravTest} \\
              \hline
              Augmentable SM template & \tt{---} & \tt{Template} \\
              \hline
            \end{tabular}
          \end{center}
   \caption{\label{tab:models} List of models available in
           \whizard. There are pure test models or models implemented
           for theoretical investigations, a long list of SM variants
           as well as a large number of BSM models.}
 \end{table}
 
 \subsubsection{Strongly Interacting Models and Composite Models}
 
 Higgsless models have been studied extensively before the Higgs boson
 discovery at the LHC Run I in 2012 in order to detect possible
 loopholes in the electroweak Higgs sector discovery potential of this
 collider. The Threesite Higgsless Model is one of the simplest
 incarnations of these models, and was one of the first BSM models
 beyond SUSY and Little Higgs models that have been implemented in
 \whizard~\cite{Speckner:2010zi}. It is also called the Minimal
 Higgsless Model (MHM)~\cite{Chivukula:2006cg} is a  minimal
 deconstructed Higgsless model which contains only the first resonance
 in  the tower of Kaluza-Klein modes of a Higgsless extra-dimensional
 model. It is a non-renormalizable, effective theory whose
 gauge group is an extension of the SM with an extra $SU(2)$ gauge
 group.  The breaking of the extended electroweak gauge symmetry is
 accomplished by a set of nonlinear sigma fields which represent the
 effects of physics at a higher scale and make the theory
 nonrenormalizable. The physical vector boson spectrum contains the
 usual photon, $W^\pm$ and $Z$ bosons as well as a $W'^\pm$ and $Z'$
 boson.  Additionally, a new set of heavy fermions are introduced to
 accompany the new gauge group ``site'' which mix to form the physical
 eigenstates.  This mixing is controlled by the small mixing parameter
 $\epsilon_L$ which is adjusted to satisfy constraints from precision
 observables, such as the S parameter~\cite{Chivukula:2005xm}.
 Here, additional weak gauge boson production at the LHC was
 one of the focus of the studies with \whizard~\cite{Ohl:2008ri}.
 
 
 \subsubsection{Supersymmetric Models}
 
 \whizard/\oMega\ was the first multi-leg matrix-element/event
 generator to include the full Minimal Supersymmetric Standard Model
 (MSSM), and also the NMSSM. The SUSY implementations in \whizard\ have
 been extensively tested~\cite{Ohl:2002jp,Reuter:2009ex}, and have been
 used for many theoretical and experimental studies (some prime
 examples
 being~\cite{Kalinowski:2008fk,Robens:2008sa,Hagiwara:2005wg}.
 
 \subsubsection{Little Higgs Models}
 
 \subsubsection{Inofficial models}
 
 There have been several models that have been included within the
 \whizard/\oMega\ framework but never found their way into the official
 release series. One famous example is the non-commutative extension of
 the SM, the NCSM. There have been several studies, e.g. simulations on
 the $s$-channel production of a $Z$ boson at the photon collider
 option of the ILC~\cite{Ohl:2004tn}. Also, the production of
 electroweak gauge bosons at the LHC in the framework of the NCSM have
 been studied~\cite{Ohl:2010zf}.
 
 
 %%%%%%%%%%%%%%%
 
 \section{The SUSY Les Houches Accord (SLHA) interface}
 \label{sec:slha}
 
 
 To be filled in
 ...~\cite{Skands:2003cj,AguilarSaavedra:2005pw,Allanach:2008qq}.
 
 The neutralino sector deserves special attention. After
 diagonalization of the mass matrix expresssed in terms
 of the gaugino and higgsino eigenstates, the resulting mass
 eigenvalues may be either negative or positive. In this case, two
 procedures can be followed.  Either the masses are rendered
 positive and the associated mixing matrix gets purely imaginary
 entries or the masses are kept signed, the mixing matrix in this case
 being real.  According to the SLHA agreement, the second option is
 adopted. For a specific eigenvalue, the phase is absorbed into the
 definition of the relevant eigenvector, rendering the mass
 negative. However, \whizard\ has not yet officially tested for
 negative masses. For external SUSY models
 (cf.~Chap.~\ref{chap:extmodels}) this means, that one must be careful
 using a SLHA file with explicit factors of
 the complex unity in the mixing matrix, and on the other hand,
 real and positive masses for the neutralinos. For the hard-coded SUSY
 models, this is completely handled internally. Especially
 Ref.~\cite{Hagiwara:2005wg} discusses the details of the neutralino
 (and chargino) mixing matrix.
 
 %%%%%%%%%%%%%%%%
 
 \section{Lepton Collider Beam Spectra}
 \label{sec:beamspectra}
 
 For the simulation of lepton collider beam spectra there are two
 dedicated tools, \circeone\ and \circetwo\ that have been written as
 in principle independent tools. Both attempt to describe the
 details of electron (and positron) beams in a realistic lepton
 collider environment. Due to the quest for achieving high peak
 luminosities at $e^+e^-$ machines, the goal is to make the spatial
 extension of the beam as small as possible but keeping the area of the
 beam roughly constant. This is achieved by forcing the beams in the
 final focus into the shape of a quasi-2D bunch. Due to the high charge
 density in that bunch, the bunch electron distribution is modified by
 classical electromagnetic radiation, so called {\em beamstrahlung}.
 The two \circe\ packages are intended to perform a simulation of this
 beamstrahlung and its consequences on the electron beam spectrum as
 realistic as possible. More details about the two packages can be
 found in their stand-alone documentations. We will discuss the basic
 features of lepton-collider beam simulations in the next two sections,
 including the technicalities of passing simulations of the machine
 beam setup to \whizard. This will be followed by a section on the
 simulation of photon collider spectra, included for historical
 reasons.
 
 %%%%%
 
 \subsection{\circeone}
 
 While the bunches in a linear collider cross only once, due to their
 small size they experience a strong beam-beam effect. There is a
 code to simulate the impact of this effect on luminosity and
 background, called
 \ttt{GuineaPig++}~\cite{Schulte:1998au,Schulte:1999tx,Schulte:2007zz}.
 This takes into account the details of the accelerator, the final
 focus etc. on the structure of the beam and the main features of the
 resulting energy spectrum of the electrons and positrons. It offers
 the state-of-the-art simulation of lepton-collider beam spectra as
 close as possible to reality. However, for many high-luminosity
 simulations, event files produced with \ttt{GuineaPig++} are usually
 too small, in the sense that not enough independent events are
 available for physics simulations. Lepton collider beam spectra do
 peak at the nominal beam energy ($\sqrt{s}/2$) of the collider, and
 feature very steeply falling tails. Such steeply falling distributions
 are very poorly mapped by histogrammed distributions with fixed bin
 widths.
 
 The main working assumption to handle such spectra are being followed
 within \circeone:
 \begin{enumerate}
 \label{circe1_assumptions}
 \item The beam spectra for the two beams $P_1$ and $P_2$ factorize
   (here $x_1$ and $x_2$ are the energy fractions of the two beams,
   respectively):
   \begin{equation*}
     D_{P_1P_2} (x_1, x_2) = D_{P_1} (x_1) \cdot D_{P_2} (x_2)
   \end{equation*}
 
 \item
   The peak is described with a delta distribution, and the tail with a
   power law:
   \begin{equation*}
     D(x) = d \cdot \delta(1-x) \; + \; c \cdot x^\alpha \, (1-x)^\beta
   \end{equation*}
 \end{enumerate}
 The two powers $\alpha$ and $\beta$ are the main coefficients that can
 be tuned in order to describe the spectrum with \circeone\ as close as
 possible as the original \ttt{GuineaPig++} spectrum. More details
 about how \circeone\ works and what it does can be found in its own
 write-up in \ttt{circe1/share/doc}.
 
 \subsection{\circetwo}
 
 The two conditions listed in \ref{circe1_assumptions} are too
 restrictive and hence insufficient to describe more complicated
 lepton-collider beam spectra, as they e.g. occur in the CLIC
 drive-beam design. Here, the two beams are highly correlated and also
 a power-law description does not give good enough precision for the
 tails. To deal with these problems, \circetwo\ starts with a
 two-dimensional histogram featuring factorized, but variable bin
 widths in order to simulate the steep parts of the
 distributions. The limited statistics from too small
 \ttt{GuineaPig++} event output files leads to correlated
 fluctuations that would leave strange artifacts in the
 distributions. To abandon them, Gaussian filters are applied to smooth
 out the correlated fluctuations. Here care has to be taken when going
 from the continuum in $x$ momentum fraction space to the corresponding
 \begin{figure}
   \centering
   \includegraphics{circe2-smoothing}
   \caption{\label{fig:circe2-smoothing}
     Smoothing the bin at the $x_{e^+} = 1$ boundary with Gaussian
     filters of 3 and 10 bins width compared to no smoothing.}
 \end{figure}
 boundaries: separate smoothing procedures are being applied to the
 bins in the continuum region and those in the boundary in order to
 avoid artificial unphysical beam energy
 spreads. Fig.~\ref{fig:circe2-smoothing} shows the smoothing of the
 distribution for the bin at the $x_{e^+} = 1$ boundary. The blue dots
 show the direct \ttt{GuineaPig++} output comprising the
 fluctuations due to the low statistics. Gaussian filters with widths
 of 3 and 10 bins, respectively, have been applied (orange and green
 dots, resp.). While there is still considerable fluctuation for 3 bin
 width Gaussian filtering, the distribution is perfectly smooth for 10
 bin width. Hence, five bin widths seem a reasonable compromise for
 histograms with a total of 100 bins. Note that the bins are not
 equidistant, but shrink with a power law towards the $x_{e^-} = 1$
 boundary on the right hand side of Fig.~\ref{fig:circe2-smoothing}.
 
 \whizard\ ships (inside its subpackage \circetwo) with prepared beam
 spectra ready to be used within \circetwo\ for the ILC beam spectra
 used in the ILC
 TDR~\cite{Behnke:2013xla,Baer:2013cma,Adolphsen:2013jya,Adolphsen:2013kya,Behnke:2013lya}. These
 comprise the designed staging energies of 200 GeV, 230 GeV, 250 GeV,
 350 GeV, and 500 GeV. Note that all of these spectra up to now do not
 take polarization of the original beams on the beamstrahlung into
 account, but are polarization-averaged. For backwards compatibility,
 also the 500 GeV spectra for the TESLA
 design~\cite{AguilarSaavedra:2001rg,Richard:2001qm}, here both for
 polarized and polarization-averaged cases, are included. Correlated
 spectra for CLIC staging energies like 350 GeV, 1400 GeV and 3000 GeV
 are not yet (as of version 2.2.4) included in the \whizard\
 distribution.
 
 In the following we describe how to obtain such files with the tools
 included in \whizard (resp. \circetwo). The procedure is equivalent to
 the so-called \ttt{lumi-linker} construction used by Timothy
 Barklow (SLAC) together with the legacy version \whizard\ttt{ 1.95}.
 The workflow to produce such files is to run \ttt{GuineaPig++} with
 the following input parameters:
 \begin{Code}
   do_lumi = 7;
   num_lumi = 100000000;
   num_lumi_eg = 100000000;
   num_lumi_gg = 100000000;
 \end{Code}
 This demands from \ttt{GuineaPig++} the generation of distributions
 for the $e^-e^+$, $e^\mp \gamma$, and $\gamma\gamma$ components of the
 beamstrahlung's spectrum, respectively. These are the files
 \ttt{lumi.ee.out}, \ttt{lumi.eg.out}, \ttt{lumi.ge.out}, and
 \ttt{lumi.gg.out}, respectively. These contain pairs $(E_1, E_2)$
 of beam energies, {\em not} fractions of the original beam
 energy. Huge event numbers are out in here, as \ttt{GuineaPig++}
 will produce only a small fraction due to a very low generation
 efficiency.
 
 The next step is to transfer these output files from
 \ttt{GuineaPig++} into input files used with \circetwo. This is
 done by means of the tool \ttt{circe\_tool.opt} that is installed
 together with the \whizard\ main binary and libraries. The user should
 run this executable with the following input file:
 \begin{Code}
 { file="ilc500/ilc500.circe"                   # to be loaded by WHIZARD
   { design="ILC" roots=500 bins=100 scale=250 # E in [0,1]
     { pid/1=electron pid/2=positron pol=0     # unpolarized e-/e+
       events="ilc500/lumi.ee.out" columns=2   # <= Guinea-Pig
       lumi = 1564.763360                      # <= Guinea-Pig
       iterations = 10                         # adapting bins
       smooth = 5 [0,1) [0,1)                  # Gaussian filter 5 bins
       smooth = 5 [1] [0,1) smooth = 5 [0,1) [1] } } }
 \end{Code}
 The first line defines the output file, that later can be read in into
 the beamstrahlung's description of \whizard\ (cf. below). Then, in the
 second line the design of the collider (here: ILC for 500 GeV
 center-of-mass energy, with the number of bins) is specified. The next
 line tells the tool to take the unpolarized case, then the
 \ttt{GuineaPig++} parameters (event file and luminosity) are
 set. In the last three lines, details concerning the adaptation of the
 simulation as well as the smoothing procedure are being specified: the
 number of iterations in the adaptation procedure, and for the
 smoothing with the Gaussian filter first in the continuum and then at
 the two edges of the spectrum. For more details confer the
 documentation in the \circetwo\ subpackage.
 
 This produces the corresponding input files that can be used within
 \whizard\ to describe beamstrahlung for lepton colliders, using a
 \sindarin\ input file like:
 \begin{Code}
         beams = e1, E1 => circe2
         $circe2_file = "ilc500.circe"
         $circe2_design = "ILC"
         ?circe2_polarized = false
 \end{Code}
 
 
 %%%%%
 
 \subsection{Photon Collider Spectra}
 
 For details confer the complete write-up of the \circetwo\
 subpackage.
 
 %%%%%
 
 \section{Transverse momentum for ISR photons}
 \label{sec:isr-photon-handler}
 
 The structure functions that describe the splitting of a beam particle
 into a particle pair, of which one enters the hard interaction and the
 other one is radiated, are defined and evaluated in the strict
 collinear approximation.  In particular, this holds for the ISR
 structure function which describes the radiation of photons off a
 charged particle in the initial state.
 
 The ISR structure function that is used by \whizard\ is understood to
 be inclusive, i.e., it implicitly contains an integration over
 transverse momentum.  This approach is to be used for computing a
 total cross section via \ttt{integrate}.  In \whizard, it is possible
 to unfold this integration, as a transformation that is applied by
 \ttt{simulate} step, event by event.  The resulting modified events
 will show a proper logarithmic momentum-transfer ($Q^2$) distribution
 for the radiated photons.  The recoil is applied to the
 hard-interaction system, such that four-momentum and $\sqrt{\hat s}$
 are conserved.  The distribution is cut off by $Q_{\text{max}}^2$
 (cf. \ttt{isr\_q\_max}) for large momentum transfer, and smoothly by
 the parton mass (cf.\ \ttt{isr\_mass}) for small momentum transfer.
 
 To activate this modification, set
 \begin{Code}
   ?isr_handler = true
   $isr_handler_mode = "recoil"
 \end{Code}
 before, or as an option to, the \ttt{simulate} command.
 
 Limitations: the current implementation of the $p_T$ modification
 works only for the symmetric double-ISR case, i.e., both beams have to
 be charged particles with identical mass (e.g., $e^+e^-$).  The mode
 \ttt{recoil} generates exactly one photon per beam, i.e., it modifies
 the momentum of the single collinear photon that the ISR structure
 function implementation produces, for each beam.  (It is foreseen that
 further modes or options will allow to generate multiple photons.
 Alternatively, the \pythia\ shower can be used to simulate multiple
 photons radiated from the initial state.)
 
 %%%%%
 
 \section{Transverse momentum for the EPA approximation}
 \label{sec:epa-beam-handler}
 
 For the equivalent-photon approximation (EPA), which is also defined
 in the collinear limit, recoil momentum can be inserted into generated
 events in an entirely analogous way.  The appropriate settings are
 \begin{Code}
   ?epa_handler = true
   $epa_handler_mode = "recoil"
 \end{Code}
 
 Limitations: as for ISR, the current implementation of the $p_T$
 modification works only for the symmetric double-EPA case.  Both
 incoming particles of the hard process must be photons, while both
 beams must be charged particles with identical mass (e.g., $e^+e^-$).
 Furthermore, the current implementation does not respect the
 kinematical limit parameter \verb|epa_q_min|, it has to be set to
 zero. In effect, the lower $Q^2$ cutoff is determined by the
 beam-particle mass \verb|epa_mass|, and the upper cutoff is either
 given by $Q_{\text{max}}$ (the parameter
 \verb|epa_q_max|), or by the limit $\sqrt{s}$ if this is not set.
 
 It is possible to combine the ISR and EPA handlers, for processes
 where ISR is active for one of the beams, EPA for the other beam.  For
 this scenario to work, both handler switches must be on, and both mode
 strings must coincide.  The parameters are set separately for ISR and
 EPA, as described above.
 
 %%%%%
 
 \section{Resonances and continuum}
 
 \subsection{Complete matrix elements}
 
 Many elementary physical processes are composed of contributions that can be
 qualified as (multiply) \emph{resonant} or \emph{continuum}.  For instance,
 the amplitude for the process $e^+e^-\to q\bar q q\bar q$, evaluated at tree
 level in perturbation theory, contains Feynman diagrams with zero, one, or two
 $W$ and $Z$ bosons as virtual lines.  If the kinematical constraints allow
 this, two vector bosons can become simultaneously on-shell in part of phase
 space.  To a first approximation, this situation is understood as $W^+W^-$ or
 $ZZ$ production with subsequent decay.  The kinematical distributions show
 distinct resonances in the quark-pair spectra.  Other graphs contain only one
 s-channel $W/Z$ boson, or none at all, such as graphs with $q\bar q$
 production and subsequent gluon radiation, splitting into another $q\bar q$
 pair.
 
 A \whizard\ declaration of the form
 \begin{Code}
         process q4 = e1, E1 => u, U, d, D
 \end{Code}
 produces the full set of graphs for the selected final state, which after
 squaring and integrating yields the exact tree-level result for the process.
 The result contains all doubly and singly resonant parts, with correct
 resonance shapes, as well as the continuum contribution and all interference.
 This is, to given order in perturbation theory, the best possible
 approximation to the true result.
 
 \subsection{Processes restricted to resonances}
 
 For an intuitive separation of a two-boson ``signal'' contribution, it is
 possible to restrict the set of graphs to a certain intermediate state.  For
 instance, the declaration
 \begin{Code}
   process q4_zz = e1, E1 => u, U, d, D { $restrictions = "3+4~Z && 5+6~Z" }
 \end{Code}
 generates an amplitude that contains only those Feynman graphs where the
 specified quarks are connected to a $Z$ virtual line.  The result may be
 understood as $ZZ$ production with subsequent decay, where the $Z$ resonances
 exhibit a Breit-Wigner shape.  Combining this with the
 analogous $W^+W^-$ restricted process, the user can generate ``signal''
 processes.
 
 Adding both ``signal'' cross sections $WW$ and $ZZ$ will result in a
 reasonable approximation to the exact tree-level cross section.  The amplitude
 misses the single-resonant and continuum contributions, and the squared
 amplitude misses the interference terms, however.  More importantly, the
 restricted processes as such are not gauge-invariant (with respect to the
 electroweak gauge group), and they are no longer dominant away from resonant
 kinematics.  We therefore strongly recommend that such restricted processes
 are always accompanied by a cut setup that restricts the kinematics to an
 approximately on-shell pattern for both resonances.  For instance:
 \begin{Code}
   cuts = all 85 GeV < M < 95 GeV [u:U]
      and all 85 GeV < M < 95 GeV [d:D]
 \end{Code}
 In this region, the gauge-dependent and continuum contributions are strictly
 subdominant.  Away from the resonance(s), the results for a restricted process
 are meaningless, and the full process has to be computed instead.
 
 \subsection{Factorized processes}
 
 Another method for obtaining the signal contribution is a proper factorization
 into resonance production and decay.  We would have to generate a production
 process and two decay processes:
 \begin{Code}
         process z_uu = Z => u, U
         process z_dd = Z => d, D
         process zz = e1, E1 => Z, Z
 \end{Code}
 All three processes must be integrated.  The integration results are partial
 decay widths and the $ZZ$ production cross section, respectively.  (Note that
 cut expressions in \sindarin\ apply to all integrations, so make sure that
 no production-process cuts are active when integrating the decay
 processes.)
 
 During a later event-generation step, the $Z$ decays can then be activated by declaring the $Z$ as
 unstable,
 \begin{Code}
         unstable Z (z_uu, z_dd)
 \end{Code}
 and then simulating the production process
 \begin{Code}
         simulate (zz)
 \end{Code}
 The generated events will consist of four-fermion final states, including all
 combinations of both decay modes.  It is important to note that in this setup,
 the invariant $u\bar u$ and $d\bar d$ masses will be always \emph{exactly}
 equal to the $Z$ mass.  There is no Breit-Wigner shape involved.  However, in
 this approximation the results are gauge-invariant, as there is no off-shell
 contribution involved.
 
 For further details on factorized processes and spin correlations,
 cf.\ Sec.~\ref{sec:spin-correlations}.
 
 
 \subsection{Resonance insertion in the event record}
 
 From the above discussion, we may conclude that it is always preferable to
 compute the complete process for a given final state, as long as this is
 computationally feasible.  However, in the simulation step this approach also
 has a drawback.  Namely, if a parton-shower module (see below) is switched on,
 the parton-shower algorithm relies on event details in order to determine the
 radiation pattern of gluons and further splitting.  In the generated event
 records, the full-process events carry the signature of non-resonant continuum
 production with no intermediate resonances.  The parton shower will thus start
 the evolution at the process energy scale, the total available energy.  By
 contrast, for an electroweak production and decay process, the evolution
 should start only at the vector boson mass, $m_Z$.  In effect, even though the
 resonant contribution of $WW$ and $ZZ$ constitutes the bulk of the cross
 section, the radiation pattern follows the dynamics of four-quark continuum
 production.  In general, the number of radiated hadrons will be too high.
 
 
 \begin{figure}
   \begin{center}
     \includegraphics[width=.41\textwidth]{resonance_e_gam}
     \includegraphics[width=.41\textwidth]{resonance_n_charged} \\
     \includegraphics[width=.41\textwidth]{resonance_n_hadron}
     \includegraphics[width=.41\textwidth]{resonance_n_particles} \\
     \includegraphics[width=.41\textwidth]{resonance_n_photons}
     \includegraphics[width=.41\textwidth]{resonance_n_visible}
   \end{center}
   \caption{The process $e^+e^- \to jjjj$ at 250 GeV center-of-mass
     energy is compared transferring the partonic events naively to the
     parton shower, i.e. without respecting any intermediate resonances
     (red lines). The blue lines show the process factorized into $WW$
     production and decay, where the shower knows the origin of the two
     jet pairs. The orange and dark green lines show the resonance
     treatment as mentioned in the text, with
     \ttt{resonance\_on\_shell\_limit = 1} and \ttt{= 4},
     respectively. \pythiasix\ parton shower and hadronization with the
     OPAL tune have been used. The observables are: photon energy
     distribution and number of charged tracks (upper line left/right,
     number of hadrons and total number of particles (middle
     left/right), and number of photons and neutral particles (lower
     line left/right).}
 \end{figure}
 
 To overcome this problem, there is a refinement of the process description
 available in \whizard.  By modifying the process declaration to
 \begin{Code}
   ?resonance_history = true
   resonance_on_shell_limit = 4
   process q4 = e1, E1 => u, U, d, D
 \end{Code}
 we advise the program to produce not just the complete matrix element, but
 also all possible restricted matrix elements containing resonant intermediate
 states.  This has no effect at all on the integration step, and thus on the
 total cross section.
 
 However, when subsequently events are generated with this setting, the program
 checks, for each event, the kinematics and determines the set of potentially
 resonant contributions.  The criterion is whether the off-shellness of a
 particular would-be resonance is less than the resonance width multiplied by
 the value of \verb|resonance_on_shell_limit| (default value $=4$).  For the
 set of resonance histories which pass this criterion (which can be empty),
 their respective squared matrix element is related to the full-process matrix
 element.  The ratio is interpreted as a probability.  The random-number
 generator then selects one or none of the resonance histories, and modifies
 the event record accordingly.  In effect, for an appropriate fraction of the
 events, depending on the kinematics, the parton-shower module is provided with
 resonance information, so it can adjust the radiation pattern accordingly.
 
 It has to be mentioned that generating the matrix-element code for all
 possible resonance histories takes additional computing resources.  In the
 current default setup, this feature is switched off.  It has to be explicitly
 activated via the \verb|?resonance_history| flag.
 
 Also, the feature can be activated or deactivated individually for
 each process, such as in
 \begin{Code}
   ?resonance_history = true
   process q4_with_res = e1, E1 => u, U, d, D  { ?resonance_history = true }
   process q4_wo_res   = e1, E1 => u, U, d, D  { ?resonance_history = false }
 \end{Code}
 If the flag is \verb|false| for a process, no resonance code will be
 generated.  Similarly, the flag has to be globally or locally active
 when \verb|simulate| is called, such that the feature takes effect for
 event generation.
 
 There are two additional parameters that can fine-tune the conditions for
 resonance insertion in the event record.  Firstly, the parameter
 \verb|resonance_on_shell_turnoff|, if nonzero, enables a Gaussian suppression
 of the probability for resonance insertion.  For instance, setting
 \begin{Code}
   ?resonance_history = true
   resonance_on_shell_turnoff = 4
   resonance_on_shell_limit = 8
 \end{Code}
 will reduce the probability for the event to be qualified as resonant by
 $e^{-1}= 37\,\%$ if the kinematics is off-shell by four units of the width,
 and by $e^{-4}=2\,\%$ at eight units of the width.  Beyond this point, the
 setting of the \verb|resonance_on_shell_limit| parameter eliminates resonance
 insertion altogether.  In effect, the resonance-background transition is
 realized in a smooth way.  Secondly, within the resonant-kinematics range the
 probability for qualifying the event as background can be reduced by the
 parameter \verb|resonance_background_factor| (default value $=1$) to a number
 between zero and one.  Setting this to zero means that the event will be
 necessarily qualified as resonant, if it falls within the resonant-kinematics
 range.
 
 Note that if an event, by the above mechanism, is identified as following a
 certain resonance history, the assigned color flow will be chosen to match the
 resonance history, not the complete matrix element.  This may result in a
 reassignment of color flow with respect to the original partonic event.
 
 Finally, we mention the order of execution: any additional
 matrix element code is compiled and linked when \verb|compile| is
 executed for the processes in question.  If this command is omitted,
 the \verb|simulate| command will trigger compilation.
 
 
 \section{Parton showers and Hadronization}
 
 In order to produce sensible events, final state QCD (and also QED)
 radiation has to be considered as well as the binding of strongly
 interacting partons into mesons and baryons. Furthermore, final state
 hadronic resonances undergo subsequent decays into those particles
 showing up in (or traversing) the detector. The latter are mostly
 pions, kaons, photons, electrons and muons.
 
 The physics associated with these topics can be divided into the
 perturbative part which is the regime of the parton shower, and the
 non-perturbative part which is the regime for the
 hadronization. \whizard\ comes with its own two different parton
 shower implementations, an analytic and a so-called $k_T$-ordered
 parton shower that will be detailed in the next section.
 
 Note that in general it is not advisable to use different shower and
 hadronization methods, or in other words, when using shower and
 hadronization methods from different programs these would have to be
 tuned together again with the corresponding data.
 
 Parton showers are approximations to full matrix elements taking only
 the leading color flow into account, and neglecting all interferences
 between different amplitudes leading to the same exclusive final
 state. They rely on the QCD (and QED) splitting functions to describe
 the emissions of partons off other partons. This is encoded in the
 so-called Sudakov form factor~\cite{Sudakov:1954sw}:
 \begin{equation*}
   \Delta( t_1, t_2) = \exp \left[ \int\limits_{t_1}^{t_2} \mbox{d} t
     \int\limits_{z_-}^{z_+} \mbox{d} z \frac{\alpha_s}{2 \pi t} P(z)
     \right]
 \end{equation*}
 This gives the probability for a parton to evolve from scale $t_2$ to
 $t_1$ without any further emissions of partons. $t$ is the evolution
 parameter of the shower, which can be a parton energy, an emission
 angle, a virtuality, a transverse momentum etc. The variable $z$
 relates the two partons after the branching, with the most common
 choice being the ratio of energies of the parton after and before the
 branching. For final-state radiation brachings occur after the hard
 interaction, the evolution of the shower starts at the scale of the
 hard interaction, $t \sim \hat{s}$, down to a cut-off scale $t =
 t_{\text{cut}}$ that marks the transition to the non-perturbative
 regime of hadronization. In the space-like evolution for the
 initial-state shower, the evolution is from a cut-off representing the
 factorization scale for the parton distribution functions (PDFs) to the
 inverse of the hard process scale, $-\hat{s}$. Technically, this
 evolution is then backwards in (shower) time~\cite{Sjostrand:1985xi},
 leading to the necessity to include the PDFs in the Sudakov factors.
 
 The main switches for the shower and hadronization which are realized
 as transformations on the partonic events within \whizard\ are
 \ttt{?allow\_shower} and \ttt{?allow\_hadronization}, which are
 true by default and only there for technical reasons. Next, different
 shower and hadronization methods can be chosen within \whizard:
 \begin{code}
   $shower_method = "WHIZARD"
   $hadronization_method = "PYTHIA6"
 \end{code}
 The snippet above shows the default choices in \whizard\, namely
 \whizard's intrinsic parton shower, but \pythiasix\ as hadronization
 tool. (Note that \whizard\ does not have its own hadronization module
 yet.)  The usage of \pythiasix\ for showering and hadronization will
 be explained in Sec.~\ref{sec:pythia6}, while the two different
 implementations of the \whizard\ homebrew parton showers are discussed
 in Sec.~\ref{sec:ktordered} and~\ref{sec:analytic}, respectively.
 
 %%%%%
 
 \subsection{The $k_T$-ordered parton shower}
 \label{sec:ktordered}
 
 %%%%%
 
 \subsection{The analytic parton shower}
 \label{sec:analytic}
 
 %%%%%
 
 \subsection{Parton shower and hadronization from \pythiasix}
 \label{sec:pythia6}
 
 Development of the \pythiasix\ generator for parton shower and
 hadronization (the \fortran\ version) has been discontinued by the
 authors several years ago. Hence, the final release of that program is
 frozen. This allowed to ship this final version, v6.427, with the
 \whizard\ distribution without the need of updating it all the
 time. One of the main reasons for that inclusion -- besides having the
 standard tool for showering and hadronization for decays at hand -- is
 to allow for backwards validation within \whizard\ particularly for
 the event samples generated for the development of linear collider
 physics: first for TESLA, JLC and NLC, and later on for the Conceptual
 and Technical Design Report for ILC, for the Conceptual Design Report
 for CLIC as well as for the Letters of Intent for the LC detectors,
 ILD and SiD.
 
 Usually, an external parton shower and hadronization program (PS) is
 steered via the transfer of event files that are given to the PS via
 LHE events, while the PS program then produces hadron level events,
 usually in HepMC format. These can then be directed towards a full or
 fast detector simulation program. As \pythiasix\ has been completely
 integrated inside the \whizard\ framework, the showered or more
 general hadron level events can be returned to and kept inside
 \whizard's internal event record, and hence be used in \whizard's
 internal event analysis. In that way, the events can be also written
 out in event formats that are not supported by \pythiasix,
 e.g. \ttt{LCIO} via the output capabilities of \whizard.
 
 There are several switches to directly steer \pythiasix\ (the values
 in brackets correspond to the \pythiasix\ variables):
 \begin{code}
   ps_mass_cutoff = 1 GeV                  [PARJ(82)]
   ps_fsr_lambda = 0.29 GeV                [PARP(72)]
   ps_isr_lambda = 0.29 GeV                [PARP(61)]
   ps_max_n_flavors = 5                    [MSTJ(45)]
   ?ps_isr_alphas_running = true           [MSTP(64)]
   ?ps_fsr_alphas_running = true           [MSTJ(44)]
   ps_fixed_alphas = 0.2                   [PARU(111)]
   ?ps_isr_angular_ordered = true          [MSTP(62)]
   ps_isr_primordial_kt_width = 1.5 GeV    [PARP(91)]
   ps_isr_primordial_kt_cutoff = 5.0 GeV   [PARP(93)]
   ps_isr_z_cutoff = 0.999                 [1-PARP(66)]
   ps_isr_minenergy = 2 GeV                [PARP(65)]
   ?ps_isr_only_onshell_emitted_partons =
         true                              [MSTP(63)]
 \end{code}
 The values given above are the default values. The first value
 corresponds to the \pythiasix\ parameter \ttt{PARJ(82)}, its
 squared being the minimal virtuality that is allowed for the parton
 shower, i.e. the cross-over to the hadronization. The same parameter
 is used also for the \whizard\ showers. \ttt{ps\_fsr\_lambda} is
 the equivalent of \ttt{PARP(72)} and is the $\Lambda_{\text{QCD}}$
 for the final state shower. The corresponding variable for the initial
 state shower is called \ttt{PARP(61)} in \pythiasix. By the next
 variable (\ttt{MSTJ(45)}), the maximal number of flavors produced
 in splittings in the shower is given, together with the number of
 active flavors in the running of
 $\alpha_s$. \ttt{?ps\_isr\_alphas\_running} which corresponds to
 \ttt{MSTP(64)} in \pythiasix\ determines whether or net a running
 $\alpha_s$ is taken in the space-like initial state showers. The same
 variable for the final state shower is \ttt{MSTJ(44)}. For fixed
 $\alpha_s$, the default value is given by \ttt{ps\_fixed\_alpha},
 corresponding to \ttt{PARU(111)}. \ttt{MSTP(62)} determines
 whether the ISR shower is angular order, i.e. whether angles are
 increasing towards the hard interaction. This is per default true, and
 set in the variable \ttt{?ps\_isr\_angular\_ordered}. The width of
 the distribution for the primordial (intrinsic) $k_T$ distribution
 (which is a non-perturbative quantity) is the \pythiasix\ variable
 \ttt{PARP(91)}, while in \whizard\ it is given by
 \ttt{pythia\_isr\_primordial\_kt\_width}. The next variable
 (\ttt{PARP(93}) gives the upper cutoff for that distribution, which
 is 5 GeV per default. For splitting in space-like showers, there is a
 cutoff on the $z$ variable named \ttt{ps\_isr\_z\_cutoff} in
 \whizard. This corresponds to one minus the value of the
 \pythiasix\ parameter \ttt{PARP(66)}. \ttt{PARP(65)}, on the
 other hand, gives the minimal (effective) energy for a time-like or
 on-shell emitted parton on a space-like QCD shower, given by the
 \sindarin\ parameter \ttt{ps\_isr\_minenergy}. Whether or not
 partons emitted from space-like showers are allowed to be only
 on-shell is given by
 \ttt{?ps\_isr\_only\_onshell\_emitted\_partons}, \ttt{MSTP(63)}
 in \pythiasix\ language.
 For more details confer the
 \pythiasix\ manual~\cite{Sjostrand:2006za}.
 
 Any other non-standard \pythiasix\ parameter can be fed into the
 parton shower via the string variable
 \begin{code}
   $ps_PYTHIA_PYGIVE = "...."
 \end{code}
 Variables set here get preference over the ones set explicitly by
 dedicated \sindarin\ commands. For example, the OPAL tune for hadronic
 final states can be set via:
 \begin{code}
   $ps_PYTHIA_PYGIVE = "MSTJ(28)=0; PMAS(25,1)=120.; PMAS(25,2)=0.3605E-02; MSTJ(41)=2;
    MSTU(22)=2000; PARJ(21)=0.40000; PARJ(41)=0.11000; PARJ(42)=0.52000; PARJ(81)=0.25000;
    PARJ(82)=1.90000; MSTJ(11)=3; PARJ(54)=-0.03100; PARJ(55)=-0.00200; PARJ(1)=0.08500;
    PARJ(3)=0.45000; PARJ(4)=0.02500; PARJ(2)=0.31000; PARJ(11)=0.60000; PARJ(12)=0.40000;
    PARJ(13)=0.72000; PARJ(14)=0.43000; PARJ(15)=0.08000; PARJ(16)=0.08000;
    PARJ(17)=0.17000; MSTP(3)=1;MSTP(71)=1"
 \end{code}
 
 \vspace{0.5cm}
 
 A very common error that appears quite often when using
 \pythiasix\ for SUSY or any other model having a stable particle that
 serves as a possible Dark Matter candidate, is the following
 warning/error message:
 \begin{Code}
      Advisory warning type 3 given after        0 PYEXEC calls:
      (PYRESD:) Failed to decay particle  1000022 with mass   15.000
 ******************************************************************************
 ******************************************************************************
 *** FATAL ERROR: Simulation: failed to generate valid event after 10000 tries
 ******************************************************************************
 ******************************************************************************
 \end{Code}
 In that case, \pythiasix\ gets a stable particle (here the lightest
 neutralino with the PDG code 1000022) handed over and does not know
 what to do with it. Particularly, it wants to treat it as a heavy
 resonance which should be decayed, but does not know how do
 that. After a certain number of tries (in the example abobe 10k),
 \whizard\ ends with a fatal error telling the user that the event
 transformation for the parton shower in the simulation has failed
 without producing a valid event. The solution to work around that
 problem is to let \pythiasix\ know that the neutralino (or any other
 DM candidate) is stable by means of
 \begin{code}
   $ps_PYTHIA_PYGIVE = "MDCY(C1000022,1)=0"
 \end{code}
 Here, 1000022 has to be replaced by the stable dark matter candidate
 or long-lived particle in the user's favorite model. Also note that
 with other options being passed to \pythiasix\, the \ttt{MDCY}
 option above has to be added to an existing
 \ttt{\$ps\_PYTHIA\_PYGIVE} command separated by a semicolon.
 
 %%%%%
 
 \subsection{Parton shower and hadronization from \pythiaeight}
 
 \subsection{Other tools for parton shower and hadronization}
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \chapter{More on Event Generation}
 \label{chap:events}
 
 In order to perform a physics analysis with \whizard\ one has to
 generate events. This seems to be a trivial statement, but as there
 have been any questions like "My \whizard\ does not produce plots --
 what has gone wrong?" we believe that repeating that rule is
 worthwile. Of course, it is not mandatory to use \whizard's own analysis
 set-up, the user can always choose to just generate events and use
 his/her own analysis package like \ttt{ROOT}, or \ttt{TopDrawer}, or
 you name it for the analysis.
 
 Accordingly, we first start to describe how to generate events and
 what options there are -- different event formats, renaming output
 files, using weighted or unweighted events with different
 normalizations. How to re-use and manipulate already generated event
 samples, how to limit the number of events per file, etc. etc.
 
 \section{Event generation}
 
 To explain how event generation works, we again take our favourite
 example, $e^+e^- \to \mu^+ \mu^-$,
 \begin{verbatim}
   process eemm = e1, E1 => e2, E2
 \end{verbatim}
 The command to trigger generation of events is \ttt{simulate
   (<proc\_name>) \{ <options> \}}, so in our case -- neglecting any
 options for now -- simply:
 \begin{verbatim}
   simulate (eemm)
 \end{verbatim}
 When you run this \sindarin\ file you will experience a fatal error:
 \ttt{FATAL ERROR: Colliding beams: sqrts is zero (please set
 sqrts)}. This is because \whizard\ needs to compile and integrate the
 process \ttt{eemm} first before event simulation, because it needs the
 information of the corresponding cross section, phase space
 parameterization and grids. It does both automatically, but you have
 to provide \whizard\ with the beam setup, or at least with the
 center-of-momentum energy.  A corresponding \ttt{integrate} command
 like
 \begin{verbatim}
   sqrts = 500 GeV
   integrate (eemm) { iterations = 3:10000 }
 \end{verbatim}
 obviously has to appear {\em before} the corresponding \ttt{simulate}
 command (otherwise you would be punished by the same error message as
 before). Putting things in the correct order results in an output
 like:
 \begin{footnotesize}
 \begin{verbatim}
 | Reading model file '/usr/local/share/whizard/models/SM.mdl'
 | Preloaded model: SM
 | Process library 'default_lib': initialized
 | Preloaded library: default_lib
 | Reading commands from file 'bla.sin'
 | Process library 'default_lib': recorded process 'eemm'
 sqrts =  5.000000000000E+02
 | Integrate: current process library needs compilation
 | Process library 'default_lib': compiling ...
 | Process library 'default_lib': keeping makefile
 | Process library 'default_lib': keeping driver
 | Process library 'default_lib': active
 | Process library 'default_lib': ... success.
 | Integrate: compilation done
 | RNG: Initializing TAO random-number generator
 | RNG: Setting seed for random-number generator to 29912
 | Initializing integration for process eemm:
 | ------------------------------------------------------------------------
 | Process [scattering]: 'eemm'
 |   Library name  = 'default_lib'
 |   Process index = 1
 |   Process components:
 |     1: 'eemm_i1':   e-, e+ => mu-, mu+ [omega]
 | ------------------------------------------------------------------------
 | Beam structure: [any particles]
 | Beam data (collision):
 |   e-  (mass = 5.1099700E-04 GeV)
 |   e+  (mass = 5.1099700E-04 GeV)
 |   sqrts = 5.000000000000E+02 GeV
 | Phase space: generating configuration ...
 | Phase space: ... success.
 | Phase space: writing configuration file 'eemm_i1.phs'
 | Phase space: 2 channels, 2 dimensions
 | Phase space: found 2 channels, collected in 2 groves.
 | Phase space: Using 2 equivalences between channels.
 | Phase space: wood
 Warning: No cuts have been defined.
 | OpenMP: Using 8 threads
 | Starting integration for process 'eemm'
 | Integrate: iterations = 3:10000
 | Integrator: 2 chains, 2 channels, 2 dimensions
 | Integrator: Using VAMP channel equivalences
 | Integrator: 10000 initial calls, 20 bins, stratified = T
 | Integrator: VAMP
 |=============================================================================|
 | It      Calls  Integral[fb]  Error[fb]   Err[%]    Acc  Eff[%]   Chi2 N[It] |
 |=============================================================================|
    1       9216  4.2833237E+02  7.14E-02    0.02    0.02*  40.29
    2       9216  4.2829071E+02  7.08E-02    0.02    0.02*  40.29
    3       9216  4.2838304E+02  7.04E-02    0.02    0.02*  40.29
 |-----------------------------------------------------------------------------|
    3      27648  4.2833558E+02  4.09E-02    0.01    0.02   40.29    0.43   3
 |=============================================================================|
 | Time estimate for generating 10000 events: 0d:00h:00m:04s
 | Creating integration history display eemm-history.ps and eemm-history.pdf
 | Starting simulation for process 'eemm'
 | Simulate: using integration grids from file 'eemm_m1.vg'
 | RNG: Initializing TAO random-number generator
 | RNG: Setting seed for random-number generator to 29913
 | OpenMP: Using 8 threads
 | Simulation: requested number of events = 0
 |             corr. to luminosity [fb-1] =   0.0000E+00
 | Events: writing to raw file 'eemm.evx'
 | Events: generating 0 unweighted, unpolarized events ...
 | Events: event normalization mode '1'
 |         ... event sample complete.
 | Events: closing raw file 'eemm.evx'
 | There were no errors and    1 warning(s).
 | WHIZARD run finished.
 |=============================================================================|
 \end{verbatim}
 \end{footnotesize}
 
 So, \whizard\ tells you that it has entered simulation mode, but besides
 this, it has not done anything. The next step is that you have to
 demand event generation -- there are two ways to do this: you could
 either specify a certain number, say 42, of events you want to have
 generated by \whizard, or you could provide a number for an integrated
 luminosity of some experiment. (Note, that if you choose to take both
 options, \whizard\ will take the one which gives the larger event
 sample. This, of course, depends on the given process(es) -- as well
 as cuts -- and its corresponding cross section(s).) The first of these
 options is set with the command: \ttt{n\_events = <number>}, the
 second with \ttt{luminosity = <number> <opt. unit>}.
 
 Another important point already stated several times in the manual is
 that \whizard\ follows the commands in the steering \sindarin\ file in a
 chronological order. Hence, a given number of events or luminosity
 {\em after} a \ttt{simulate} command will be ignored -- or are
 relevant only for any \ttt{simulate} command potentially following
 further down in the \sindarin\ file. So, in our case, try:
 \begin{verbatim}
  n_events = 500
  luminosity = 10
  simulate (eemm)
 \end{verbatim}
 Per default, numbers for integrated luminosity are understood as
 inverse femtobarn. So, for the cross section above this would
 correspond to 4283 events, clearly superseding the demand for 500
 events. After reducing the luminosity number from ten to one inverse
 femtobarn, 500 is the larger number of events taken by \whizard\ for
 event generation. Now \whizard\ tells you:
 \begin{verbatim}
 | Simulation: requested number of events = 500
 |             corr. to luminosity [fb-1] =   1.1673E+00
 | Events: reading from raw file 'eemm.evx'
 | Events: reading 500 unweighted, unpolarized events ...
 | Events: event normalization mode '1'
 | ... event file terminates after 0 events.
 | Events: appending to raw file 'eemm.evx'
 | Generating remaining  500 events ...
 |         ... event sample complete.
 | Events: closing raw file 'eemm.evx'
 \end{verbatim}
 I.e., it evaluates the luminosity to which the sample of 500 events
 would correspond to, which is now, of course, bigger than the $1
 \fb^{-1}$ explicitly given for the luminosity. Furthermore, you can
 read off that a file \ttt{whizard.evx} has been generated, containing
 the demanded 500 events. (It was there before containing zero events,
 because to \ttt{n\_events} or \ttt{luminosity} value had been
 set. \whizard\ then tried to get the events first from file before
 generating new ones). Files with the suffix \ttt{.evx} are binary
 format event files, using a machine-dependent \whizard-specific
 event file format. Before we list the event formats supported by
 \whizard, the next two sections will tell you more about unweighted and
 weighted events as well as different possibilities to normalize events
 in \whizard.
 
 As already explained for the libraries, as well as the phase space and
 grid files in Chap.~\ref{chap:sindarin}, \whizard\ is trying to re-use
 as much information as possible. This is of course also true for the
 event files. There are special MD5 check sums testing the integrity
 and compatibility of the event files. If you demand for a process for
 which an event file already exists (as in the example above, though it
 was empty) equally many or less events than generated before,
 \whizard\ will not generate again but re-use the existing events (as
 already explained, the events are stored in a \whizard-own
 binary event format, i.e. in a so-called \ttt{.evx} file. If you
 suppress generation of that file, as will be described in subsection
 \ref{sec:eventformats} then \whizard\ has to generate events all the
 time). From version v2.2.0 of \whizard\ on, the program is also able
 to read in event from different event formats. However, most event
 formats do not contain as many information as \whizard's internal
 format, and a complete reconstruction of the events might not be
 possible. Re-using event files is very practical for doing several
 different analyses with the same data, especially if there are many
 and big data samples. Consider
 the case, there is an event file with 200 events, and you now ask
 \whizard\ to generate 300 events, then it will re-use the 200 events
 (if MD5 check sums are OK!), generate the remaining 100 events and
 append them to the existing file. If the user for some reason,
 however, wants to regenerate events (i.e. ignoring possibly existing
 events), there is the command option \ttt{whizard --rebuild-events}.
 
 %%%%%%%%%
 
 \section{Unweighted and weighted events}
 
 \whizard\ is able to generate unweighted events, i.e. events that are
 distributed uniformly and each contribute with the same event weight
 to the whole sample. This is done by mapping out the phase space of
 the process under consideration according to its different phase space
 channels (which each get their own weights), and then unweighting the
 sample of weighted events. Only a sample of unweighted events could in
 principle be compared to a real data sample from some experiment. The
 seventh column in the \whizard\ iteration/adaptation procedure tells you
 about the efficiency of the grids, i.e. how well the phase space is
 mapped to a flat function. The better this is achieved, the higher the
 efficiency becomes, and the closer the weights of the different phase
 space channels are to uniformity. This means, for higher efficiency
 less weighted events ("calls") are needed to generate a single
 unweighted event. An efficiency of 10 \% means that ten weighted
 events are needed to generate one single unweighted event. After the
 integration is done, \whizard\ uses the duration of calls during the
 adaptation to estimate a time interval needed to generate 10,000
 unweighted events. The ability of the adaptive multi-channel Monte
 Carlo decreases with the number of integrations, i.e. with the number
 of final state particles. Adding more and more final state particles
 in general also increases the complexity of phase space, especially
 its singularity structure. For a $2 \to 2$ process the efficiency is
 roughly of the order of several tens of per cent. As a rule of thumb,
 one can say that with every additional pair of final state particle
 the average efficiency one can achieve decreases by a factor of five
 to ten.
 
 The default of \whizard\ is to generate {\em unweighted} events. One can
 use the logical variable \ttt{?unweighted = false} to disable
 unweighting and generate weighted events. (The command
 \ttt{?unweighted = true} is a tautology, because \ttt{true} is the
 default for this variable.) Note that again this command has to appear
 {\em before} the corresponding \ttt{simulate} command, otherwise it will
 be ignored or effective only for any \ttt{simulate} command appearing
 later in the \sindarin\ file.
 
 In the unweighted procedure, \whizard\ is keeping track of the highest
 weight that has been appeared during the adaptation, and the
 efficiency for the unweighting has been estimated from the average
 value of the sampling function compared to the maximum value. In
 principle, during event generation no events should be generated whose
 sampling function value exceeds the maximum function value encountered
 during the grid adaptation. Sometimes, however, there are numerical
 fluctuations and such events are happening. They are called {\em
 excess events}. \whizard\ does keep track of these excess events
 during event generation and will report about them, e.g.:
 \begin{code}
 Warning: Encountered events with excess weight: 9 events (  0.090 %)
 | Maximum excess weight = 6.083E-01
 | Average excess weight = 2.112E-04
 \end{code}
 Whenever in an event generation excess events appear, this shows that
 the adaptation of the sampling function has not been perfect. When the
 number of excess weights is a finite number of percent, you should
 inspect the phase-space setup and try to improve its settings to get a
 better adaptation.
 
 %%%%%%%%%
 
 \section{Choice on event normalizations}
 
 There are basically four different choices to normalize event weights
 ($\braket{\ldots}$ denotes the average):
 \begin{enumerate}
 \item $\braket{w_i} = 1$, \qquad\qquad $\Braket{\sum_i w_i} = N$
 \item $\braket{w_i} = \sigma$, \qquad\qquad $\Braket{\sum_i w_i} = N
   \times \sigma$
 \item $\braket{w_i} = 1/N$, \quad\qquad $\Braket{\sum_i w_i} = 1$
 \item $\braket{w_i} = \sigma/N$, \quad\qquad $\Braket{\sum_i w_i} = \sigma$
 \end{enumerate}
 So the four options are to have the average weight equal to unity, to
 the cross section of the corresponding process, to one over the number
 of events, or the cross section over the event calls. In these four
 cases, the event weights sum up to the event number, the event number
 times the cross section, to unity, and to the cross section,
 respectively. Note that neither of these really guarantees that all
 event weights individually lie in the interval $0 \leq w_i \leq 1$.
 
 The user can steer the normalization of events by using in \sindarin\
 input files the string variable \ttt{\$sample\_normalization}. The default is
 \ttt{\$sample\_normalization = "auto"}, which uses option 1 for
 unweighted and 2 for weighted events, respectively. Note that this is
 also what the Les Houches Event Format (LHEF) demands for both types
 of events. This is \whizard's preferred mode, also for the reason, that
 event normalizations are independent from the number of events. Hence,
 event samples can be cut or expanded without further need to adjust
 the normalization. The unit normalization (option 1) can be switched
 on also for weighted events by setting the event normalization
 variable equal to \ttt{"1"}. Option 2 can be demanded
 by setting \ttt{\$sample\_normalization = "sigma"}. Options 3 and 4 can
 be set by \ttt{"1/n"} and \ttt{"sigma/n"}, respectively. \whizard\
 accepts small and capital letters for these expressions.
 
 In the following section we show some examples when discussing the
 different event formats available in \whizard.
 
 %%%%%%%%%
 
 \section{Event selection}
 
 The \ttt{selection} expression (cf.\ Sec.~\ref{subsec:analysis})
 reduces the event sample during generation or rescanning, selecting
 only events for which the expression evaluates to \ttt{true}.  Apart
 from internal analysis, the selection also applies to writing external
 files.  For instance, the following code generates a $e^+e^-\to
 W^+W^-$ sample with longitudinally polarized $W$ bosons only:
 \begin{footnotesize}
 \begin{verbatim}
 process ww = "e+", "e-" => "W-", "W+"
 polarized "W+"
 polarized "W-"
 ?polarized_events = true
 sqrts = 500
 selection = all Hel == 0 ["W+":"W-"]
 simulate (ww) { n_events = 1000 }
 \end{verbatim}
 \end{footnotesize}
 The number of events that end up in the sample on file is equal to the
 number of events with longitudinally polarized $W$s in the generated
 sample, so the file will contain less than 1000 events.
 
 
 %%%%%%%%%
 
 \section{Supported event formats}
 \label{sec:eventformats}
 
 Event formats can either be distinguished whether they are plain
 text (i.e. ASCII) formats or binary formats. Besides this, one can
 classify event formats according to whether they are natively
 supported by \whizard\ or need some external program or library to be
 linked. Table~\ref{tab:eventformats} gives a complete list of all
 event formats available in \whizard. The second column shows whether
 these are ASCII or binary formats, the third column contains brief
 remarks about the corresponding format, while the last column tells
 whether external programs or libraries are needed (which is the case
 only for the HepMC formats).
 
 \begin{table}
   \begin{center}
     \begin{tabular}{|l||l|l|r|}\hline
       Format & Type & remark & ext. \\\hline
       ascii & ASCII & \whizard\ verbose format & no
       \\
       Athena & ASCII & variant of HEPEVT & no
       \\
       debug & ASCII & most verbose \whizard\ format & no
       \\
       evx   & binary & \whizard's home-brew & no
       \\
       HepMC & ASCII & HepMC format & yes
       \\
       HEPEVT & ASCII & \whizard~1 style & no
       \\
       LCIO & ASCII & LCIO format & yes
       \\
       LHA  & ASCII & \whizard~1/old Les Houches style &no
       \\
       LHEF & ASCII & Les Houches accord compliant & no
       \\
       long & ASCII & variant of HEPEVT & no
       \\
       mokka & ASCII & variant of HEPEVT & no
       \\
       short & ASCII & variant of HEPEVT & no
       \\
       StdHEP (HEPEVT) & binary & based on HEPEVT common block  & no
       \\
       StdHEP (HEPRUP/EUP) & binary & based on HEPRUP/EUP common block
       & no \\
       Weight stream & ASCII & just weights & no \\
       \hline
     \end{tabular}
   \end{center}
   \caption{\label{tab:eventformats}
     Event formats supported by \whizard, classified according to
     ASCII/binary formats and whether an external program or library is
     needed to generate a file of this format. For both the HEPEVT and
     the LHA format there is a more verbose variant.
   }
 \end{table}
 The "\ttt{.evx}'' is \whizard's native binary event format. If you
 demand event generation and do not specify anything further, \whizard\
 will write out its events exclusively in this binary format. So in the
 examples discussed in the previous chapters (where we omitted all
 details about event formats), in all cases this and only this internal
 binary format has been generated. The generation of this raw format
 can be suppressed (e.g. if you want to have only one specific event
 file type) by setting the variable \verb|?write_raw = false|. However,
 if the raw event file is not present, \whizard\ is not able to re-use
 existing events (e.g. from an ASCII file) and will regenerate events
 for a given process. Note that from version v2.2.0 of \whizard\ on,
 the program is able to (partially) reconstruct complete events also
 from other formats than its internal format (e.g. LHEF), but this is
 still under construction and not yet complete.
 
 Other event formats can be written out by setting the variable
 \ttt{sample\_format = <format>}, where \ttt{<format>} can be any of
 the following supported variables:
 \begin{itemize}
 \item \ttt{ascii}: a quite verbose ASCII format which contains lots of
   information (an example is shown in the appendix). \newline
   Standard suffix: \ttt{.evt}
 \item \ttt{debug}: an even more verbose ASCII format intended for
   debugging which prints out also information about the internal data
   structures \newline
   Standard suffix: \ttt{.debug}
 \item \ttt{hepevt}: ASCII format that writes out a specific
   incarnation of the HEPEVT common block (\whizard~1
   back-compatibility) \newline
   Standard suffix: \ttt{.hepevt}
 \item \ttt{hepevt\_verb}: more verbose version of \ttt{hepevt} (\whizard~1
   back-compatibility) \newline
   Standard suffix: \ttt{.hepevt.verb}
 \item \ttt{short}: abbreviated variant of the previous HEPEVT (\whizard\
   1 back-compatibility)  \newline
   Standard suffix: \ttt{.short.evt}
 \item \ttt{long}: HEPEVT variant that contains a little bit more
   information than the short format but less than HEPEVT (\whizard\
   1 back-compatibility)  \newline
   Standard suffix: \ttt{.long.evt}
 \item \ttt{athena}: HEPEVT variant suitable for read-out in the ATLAS
   ATHENA software environment (\whizard\
   1 back-compatibility)  \newline
   Standard suffix: \ttt{.athena.evt}
 \item \ttt{mokka}: HEPEVT variant suitable for read-out in the MOKKA
   ILC software environment \newline
   Standard suffix: \ttt{.mokka.evt}
 \item \ttt{lcio}: LCIO ASCII format (only available if LCIO is
   installed and correctly linked) \newline
   Standard suffix: \ttt{.lcio}
 \item \ttt{lha}: Implementation of the Les Houches Accord as it was in
   the old MadEvent and \whizard~1 \newline
   Standard suffix: \ttt{.lha}
 \item \ttt{lha\_verb}: more verbose version of \ttt{lha} \newline
   Standard suffix: \ttt{.lha.verb}
 \item \ttt{lhef}: Formatted Les Houches Accord implementation that
   contains the XML headers \newline
   Standard suffix: \ttt{.lhe}
 \item \ttt{hepmc}: HepMC ASCII format (only available if HepMC is
   installed and correctly linked) \newline
   Standard suffix: \ttt{.hepmc}
 \item \ttt{stdhep}: StdHEP binary format based on the HEPEVT common
   block
   \newline
   Standard suffix: \ttt{.hep}
 \item \ttt{stdhep\_up}: StdHEP binary format based on the HEPRUP/HEPEUP
   common blocks
   \newline
   Standard suffix: \ttt{.up.hep}
 \item \ttt{stdhep\_ev4}: StdHEP binary format based on the HEPEVT/HEPEV4
   common blocks
   \newline
   Standard suffix: \ttt{.ev4.hep}
 \item \ttt{weight\_stream}: Format that prints out only the event
   weight (and maybe alternative ones) \newline
   Standard suffix: \ttt{.weight.dat}
 \end{itemize}
 Of course, the variable \ttt{sample\_format} can contain more than one
 of the above identifiers, in which case more  than one different event
 file format is generated. The list above also shows the standard
 suffixes for these event formats (remember, that the native binary
 format of \whizard\ does have the suffix \ttt{.evx}). (The suffix of
 the different event formats can even be changed by the user by setting
 the corresponding variable \ttt{\$extension\_lhef = "foo"} or
 \ttt{\$extension\_ascii\_short = "bread"}. The dot is automatically
 included.)
 
 The name of the corresponding event sample is taken to be the string
 of the name of the first process in the \ttt{simulate}
 statement. Remember, that conventionally the events for all processes
 in one \ttt{simulate} statement will be written into one single event
 file. So \ttt{simulate (proc1, proc2)} will write events for the two
 processes \ttt{proc1} and \ttt{proc2} into one single event file with
 name \ttt{proc1.evx}. The name can be changed by the user with the
 command \ttt{\$sample = "<name>"}.
 
 The commands \ttt{\$sample} and \ttt{sample\_format} are both accepted
 as optional arguments of a \ttt{simulate} command, so e.g.
 \ttt{simulate (proc) \{ \$sample = "foo" sample\_format = hepmc \}}
 generates an event sample in the HepMC format for the process
 \ttt{proc} in the file \ttt{foo.hepmc}.
 
 Examples for event formats, for specifications of the
 event formats correspond the different accords and publicatios:
 
 {\bf HEPEVT:}
 
 The HEPEVT is an ASCII event format that does not contain an event
 file header. There is a one-line header for each single event,
 containing four entries. The number of particles in the event
 (\ttt{ISTHEP}), which is four for a fictitious example process $hh\to
 hh$, but could be larger if e.g. beam remnants are demanded to be included in the
 event. The second entry and third entry are the number of outgoing
 particles and beam remnants, respectively. The event weight is the
 last entry. For each particle in the event there are three lines:
 the first one is the status according to the HEPEVT format,
 \ttt{ISTHEP}, the second one the PDG code, \ttt{IDHEP}, then there are
 the one or two possible mother particle, \ttt{JMOHEP}, the first and
 last possible daughter particle, \ttt{JDAHEP}, and the polarization.
 The second line contains the three momentum components, $p_x$, $p_y$,
 $p_z$, the particle energy $E$, and its mass, $m$.
 The last line contains the position of the vertex in the event
 reconstruction.
 
 \begin{scriptsize}
   \begin{verbatim}
  4 2 0  3.0574068604E+08
  2 25 0 0 3 4 0
   0.0000000000E+00  0.0000000000E+00  4.8412291828E+02  5.0000000000E+02  1.2500000000E+02
   0.0000000000E+00  0.0000000000E+00  0.0000000000E+00  0.0000000000E+00  0.0000000000E+00
  2 25 0 0 3 4 0
   0.0000000000E+00  0.0000000000E+00 -4.8412291828E+02  5.0000000000E+02  1.2500000000E+02
   0.0000000000E+00  0.0000000000E+00  0.0000000000E+00  0.0000000000E+00  0.0000000000E+00
  1 25 1 2 0 0 0
  -1.4960220911E+02 -4.6042825611E+02  0.0000000000E+00  5.0000000000E+02  1.2500000000E+02
   0.0000000000E+00  0.0000000000E+00  0.0000000000E+00  0.0000000000E+00  0.0000000000E+00
  1 25 1 2 0 0 0
   1.4960220911E+02  4.6042825611E+02  0.0000000000E+00  5.0000000000E+02  1.2500000000E+02
   0.0000000000E+00  0.0000000000E+00  0.0000000000E+00  0.0000000000E+00  0.0000000000E+00
   \end{verbatim}
 \end{scriptsize}
 
 {\bf ASCII SHORT:}
 
 This is basically the same as the HEPEVT standard, but very much
 abbreviated. The header line for each event is identical, but the first
 line per particle does only contain the PDG and the polarization,
 while the vertex information line is omitted.
 
 \begin{scriptsize}
   \begin{verbatim}
  4 2 0  3.0574068604E+08
  25 0
   0.0000000000E+00  0.0000000000E+00  4.8412291828E+02  5.0000000000E+02  1.2500000000E+02
  25 0
   0.0000000000E+00  0.0000000000E+00 -4.8412291828E+02  5.0000000000E+02  1.2500000000E+02
  25 0
  -1.4960220911E+02 -4.6042825611E+02  0.0000000000E+00  5.0000000000E+02  1.2500000000E+02
  25 0
   1.4960220911E+02  4.6042825611E+02  0.0000000000E+00  5.0000000000E+02  1.2500000000E+02
   \end{verbatim}
 \end{scriptsize}
 
 {\bf ASCII LONG:}
 
 Identical to the ASCII short format, but after each event there is a
 line containg two values: the value of the sample function to be
 integrated over phase space, so basically the squared matrix element
 including all normalization factors, flux factor, structure functions
 etc.
 
 \begin{scriptsize}
   \begin{verbatim}
  4 2 0  3.0574068604E+08
  25 0
   0.0000000000E+00  0.0000000000E+00  4.8412291828E+02  5.0000000000E+02  1.2500000000E+02
  25 0
   0.0000000000E+00  0.0000000000E+00 -4.8412291828E+02  5.0000000000E+02  1.2500000000E+02
  25 0
  -1.4960220911E+02 -4.6042825611E+02  0.0000000000E+00  5.0000000000E+02  1.2500000000E+02
  25 0
   1.4960220911E+02  4.6042825611E+02  0.0000000000E+00  5.0000000000E+02  1.2500000000E+02
   1.0000000000E+00  1.0000000000E+00
   \end{verbatim}
 \end{scriptsize}
 
 {\bf ATHENA:}
 
 Quite similar to the HEPEVT ASCII format. The header line, however,
 does contain only two numbers: an event counter, and the number of
 particles in the event. The first line for each particle lacks the
 polarization information (irrelevant for the ATHENA environment), but
 has as leading entry an ordering number counting the particles in the
 event. The vertex information line has only the four relevant position
 entries.
 
 
 \begin{scriptsize}
   \begin{verbatim}
  0 4
  1 2 25 0 0 3 4
   0.0000000000E+00  0.0000000000E+00  4.8412291828E+02  5.0000000000E+02  1.2500000000E+02
   0.0000000000E+00  0.0000000000E+00  0.0000000000E+00  0.0000000000E+00
  2 2 25 0 0 3 4
   0.0000000000E+00  0.0000000000E+00 -4.8412291828E+02  5.0000000000E+02  1.2500000000E+02
   0.0000000000E+00  0.0000000000E+00  0.0000000000E+00  0.0000000000E+00
  3 1 25 1 2 0 0
  -1.4960220911E+02 -4.6042825611E+02  0.0000000000E+00  5.0000000000E+02  1.2500000000E+02
   0.0000000000E+00  0.0000000000E+00  0.0000000000E+00  0.0000000000E+00
  4 1 25 1 2 0 0
   1.4960220911E+02  4.6042825611E+02  0.0000000000E+00  5.0000000000E+02  1.2500000000E+02
   0.0000000000E+00  0.0000000000E+00  0.0000000000E+00  0.0000000000E+00
   \end{verbatim}
 \end{scriptsize}
 
 {\bf MOKKA:}
 
 Quite similar to the ASCII short format, but the event entries are the
 particle status, the PDG code, the first and last daughter, the
 three spatial components of the momentum, as well as the mass.
 
 \begin{scriptsize}
 \begin{verbatim}
  4 2 0  3.0574068604E+08
  2 25 3 4  0.0000000000E+00  0.0000000000E+00  4.8412291828E+02  1.2500000000E+02
  2 25 3 4  0.0000000000E+00  0.0000000000E+00 -4.8412291828E+02  1.2500000000E+02
  1 25 0 0 -1.4960220911E+02 -4.6042825611E+02  0.0000000000E+00  1.2500000000E+02
  1 25 0 0  1.4960220911E+02  4.6042825611E+02  0.0000000000E+00  1.2500000000E+02
 \end{verbatim}
 \end{scriptsize}
 
 {\bf LHA:}
 
 This is the implementation of the Les Houches Accord, as it was used
 in \whizard\ 1 and the old MadEvent. There is a first line containing
 six entries: 1. the number of particles in the event, \ttt{NUP},
 2. the subprocess identification index, \ttt{IDPRUP}, 3. the event
 weight, \ttt{XWGTUP}, 4. the scale of the process, \ttt{SCALUP},
 5. the value or status of $\alpha_{QED}$, \ttt{AQEDUP}, 6. the value
 for $\alpha_s$, \ttt{AQCDUP}. The next seven lines contain as many
 entries as there are particles in the event: the first one has the PDG
 codes, \ttt{IDUP}, the next two the first and second mother of the particles,
 \ttt{MOTHUP}, the fourth and fifth line the two color indices,
 \ttt{ICOLUP}, the next one the status of the particle, \ttt{ISTUP},
 and the last line the polarization information, \ttt{ISPINUP}.
 At the end of the event there are as lines for each particles with the
 counter in the event and the four-vector of the particle. For more
 information on this event format confer~\cite{LesHouches}.
 
 \begin{scriptsize}
   \begin{verbatim}
  25 25  5.0000000000E+02  5.0000000000E+02 -1 -1 -1 -1 3 1
   1.0000000000E-01  1.0000000000E-03  1.0000000000E+00 42
      4     1  3.0574068604E+08  1.000000E+03 -1.000000E+00 -1.000000E+00
     25    25    25    25
      0     0     1     1
      0     0     2     2
      0     0     0     0
      0     0     0     0
     -1    -1     1     1
      9     9     9     9
      1  5.0000000000E+02  0.0000000000E+00  0.0000000000E+00  4.8412291828E+02
      2  5.0000000000E+02  0.0000000000E+00  0.0000000000E+00 -4.8412291828E+02
      3  5.0000000000E+02 -1.4960220911E+02 -4.6042825611E+02  0.0000000000E+00
      4  5.0000000000E+02  1.4960220911E+02  4.6042825611E+02  0.0000000000E+00
   \end{verbatim}
 \end{scriptsize}
 
 {\bf LHEF:}
 
 This is the modern version of the Les Houches accord event format
 (LHEF), for the details confer the corresponding publication~\cite{LHEF}.
 
 \begin{scriptsize}
   \begin{verbatim}
 <LesHouchesEvents version="1.0">
 <header>
   <generator_name>WHIZARD</generator_name>
   <generator_version>2.6.4</generator_version>
 </header>
 <init>
  25 25  5.0000000000E+02  5.0000000000E+02 -1 -1 -1 -1 3 1
   1.0000000000E-01  1.0000000000E-03  1.0000000000E+00 42
 </init>
 <event>
  4 42  3.0574068604E+08  1.0000000000E+03 -1.0000000000E+00 -1.0000000000E+00
  25 -1 0 0 0 0  0.0000000000E+00  0.0000000000E+00  4.8412291828E+02  5.0000000000E+02  1.2500000000E+02  0.0000000000E+00  9.0000000000E+00
  25 -1 0 0 0 0  0.0000000000E+00  0.0000000000E+00 -4.8412291828E+02  5.0000000000E+02  1.2500000000E+02  0.0000000000E+00  9.0000000000E+00
  25 1 1 2 0 0 -1.4960220911E+02 -4.6042825611E+02  0.0000000000E+00  5.0000000000E+02  1.2500000000E+02  0.0000000000E+00  9.0000000000E+00
  25 1 1 2 0 0  1.4960220911E+02  4.6042825611E+02  0.0000000000E+00  5.0000000000E+02  1.2500000000E+02  0.0000000000E+00  9.0000000000E+00
 </event>
 </LesHouchesEvents>
   \end{verbatim}
 \end{scriptsize}
 
 Note that for the LHEF format, there are different versions according
 to the different stages of agreement. They can be addressed from
 within the \sindarin\ file by setting the string variable
 \ttt{\$lhef\_version} to one of (at the moment) three values:
 \ttt{"1.0"}, \ttt{"2.0"}, or \ttt{"3.0"}. The examples above
 corresponds (as is indicated in the header) to the version \ttt{"1.0"}
 of the LHEF format. Additional information in form of alternative
 squared matrix elements or event weights in the event are the most
 prominent features of the other two more advanced versions. For more
 details confer the literature.
 
 \vspace{.5cm}
 
 Sample files for the default ASCII format as well as for the debug
 event format are shown in the appendix.
 
 %%%%%%%%%
 
 \section[Interfaces to Parton Showers, Matching and
 Hadronization]{Interfaces to Parton Showers, Matching\\and
   Hadronization}
 
 This section describes the interfaces to the internal parton shower as
 well as the parton shower and hadronization routines from
 \pythia. Moreover, our implementation of the MLM matching making use
 of the parton showers is described. Sample \sindarin\ files are
 located in the \ttt{share/examples} directory.
 All input files come in two versions, one using the internal shower,
 ending in \ttt{W.sin}, and one using \pythia's shower, ending in
 \ttt{P.sin}. Thus we state all file names as ending with \ttt{X.sin},
 where \ttt{X} has to be replaced by either \ttt{W} or \ttt{P}.
 The input files include \ttt{EENoMatchingX.sin} and
 \ttt{DrellYanNoMatchingX.sin} for $e^+ e^- \to hadrons$ and $p\bar{p}
 \to Z$ without matching. The corresponding \sindarin\ files with
 matching enabled are \ttt{EEMatching2X.sin} to \ttt{EEMatching5X.sin}
 for $e^+ e^- \to hadrons$ with a different number of partons included
 in the matrix element and \ttt{DrallYanMatchingX.sin} for Drell-Yan
 with one matched emission.
 
 \subsection{Parton Showers and Hadronization}
 
 From version 2.1 onwards, \whizard\ contains an implementation of an
 analytic parton shower as presented in \cite{Kilian:2011ka}, providing
 the opportunity to perform the parton shower from whithin
 \whizard. Moreover, an interface to \pythia\ is included, which can be
 used to delegate the parton shower to \pythia. The same interface can
 be used to hadronize events using the generated events using \pythia's
 hadronization routines. Note that by \pythia's default, when
 performing initial-state radiation multiple interactions are included
 and when performing the hadronization hadronic decays are included. If
 required, these additional steps have to be switched off using the
 corresponding arguments for \pythia's \ttt{PYGIVE} routine vie the
 \ttt{\$ps\_PYTHIA\_PYGIVE} string.
 
 Note that from version 2.2.4 on the earlier flag
 \ttt{--enable-shower} flag has been abandoned, and there is only a
 flag to either compile or not compile the interally attached
 \pythia\ttt{6} package (\ttt{--enable-pythia6}) last release of
 the \fortran\ \pythia, v6.427) as well as the interface. It can be
 invoked by the following \sindarin\ keywords:\\[2ex]
 %
 \centerline{\begin{tabular}{|l|l|}
 \hline\ttt{?ps\_fsr\_active = true} & master switch for final-state
 parton showers\\\hline
 \ttt{?ps\_isr\_active = true} & master switch for initial-state parton
 showers\\\hline
 \ttt{?ps\_taudec\_active = true} & master switch for $\tau$ decays (at
 the moment only via \ttt{TAUOLA}\\\hline
 \ttt{?hadronization\_active = true} & master switch to enable
 hadronization\\\hline
 \ttt{\$shower\_method = "PYTHIA6"} & switch to use \pythiasix's parton
 shower instead of \\ &
  \whizard's own shower\\\hline
 \end{tabular}}\mbox{}
 
 \vspace{4mm}
 
 If either \ttt{?ps\_fsr\_active} or \ttt{?ps\_isr\_active} is set to \verb|true|, the
 event will be transferred to the internal shower routines or the \pythia\ data structures,
 and the chosen shower steps (initial- and final-state radiation) will be
 performed. If hadronization is enabled via the \ttt{?hadronization\_active} switch, \whizard\ will call \pythia's hadronization routine.
 The hadron\-ization can be applied to events showered using the internal shower or showered using \pythia's shower routines, as well as unshowered events.
 Any necessary transfer of event data to \pythia\ is automatically taken care of within \whizard's shower interface.
 The resulting (showered and/or hadronized) event will be transferred back to \whizard,
 the former final particles will be marked as intermediate. The
 analysis can be applied to a showered and/or hadronized event just
 like in the unshowered/unhadronized case. Any event file can be used
 and will contain the showered/hadronized event.
 
 Settings for the internal analytic parton shower are set via the following \sindarin\ variables:\\[2ex]
 \begin{description}
 \item[\ttt{ps\_mass\_cutoff}] The cut-off in virtuality, below
   which, partons are assumed to radiate no more. Used for both ISR and
   FSR. Given in $\mbox{GeV}$. (Default = 1.0)
 \item[\ttt{ps\_fsr\_lambda}] The value for $\Lambda$ used in
   calculating the value of the running coupling constant $\alpha_S$
   for Final State Radiation. Given in $\mbox{GeV}$. (Default = 0.29)
 \item[\ttt{ps\_isr\_lambda}] The value for $\Lambda$ used in
   calculating the value of the running coupling constant $\alpha_S$
   for Initial State Radiation. Given in $\mbox{GeV}$. (Default = 0.29)
 \item[\ttt{ps\_max\_n\_flavors}] Number of quark flavours taken
   into account during shower evolution. Meaningful choices are 3 to
   include $u,d,s$-quarks, 4 to include $u,d,s,c$-quarks and 5 to
   include $u,d,s,c,b$-quarks. (Default = 5)
 \item[\ttt{?ps\_isr\_alphas\_running}] Switch to decide between a
   constant $\alpha_S$, given by \ttt{ps\_fixed\_alphas}, and a
   running $\alpha_S$, calculated using \ttt{ps\_isr\_lambda} for
   ISR. (Default = true)
 \item[\ttt{?ps\_fsr\_alphas\_running}] Switch to decide between a
   constant $\alpha_S$, given by \ttt{ps\_fixed\_alphas}, and a
   running $\alpha_S$, calculated using \ttt{ps\_fsr\_lambda} for
   FSR. (Default = true)
 \item[\ttt{ps\_fixed\_alphas}] Fixed value of $\alpha_S$ for the
   parton shower. Used if either one of the variables
   \ttt{?ps\_fsr\_alphas\_running}
   or \ttt{?ps\_isr\_alphas\_running} are set to
   \verb|false|. (Default = 0.0)
 \item[\ttt{?ps\_isr\_angular\_ordered}] Switch for angular ordered
   ISR. (Default = true )\footnote{The FSR is always simulated with
     angular ordering enabled.}
 \item[\ttt{ps\_isr\_primordial\_kt\_width}] The width in
   $\mbox{GeV}$ of the Gaussian assumed to describe the transverse
   momentum of partons inside the proton. Other shapes are not yet
   implemented. (Default = 0.0)
 \item[\ttt{ps\_isr\_primordial\_kt\_cutoff}] The maximal transverse
   momentum in $\mbox{GeV}$ of a parton inside the proton. Used as a
   cut-off for the Gaussian. (Default = 5.0)
 \item[\ttt{ps\_isr\_z\_cutoff}] Maximal $z$-value in initial state
   branchings. (Default = 0.999)
 \item[\ttt{ps\_isr\_minenergy}] Minimal energy in $\mbox{GeV}$ of
   an emitted timelike or final parton. Note that the energy is not
   calculated in the labframe but in the center-of-mas frame of the two
   most initial partons resolved so far, so deviations may
   occur. (Default = 1.0)
 \item[\ttt{ps\_isr\_tscalefactor}] Factor for the starting scale in
   the initial state shower evolution. ( Default = 1.0 )
 \item[\ttt{?ps\_isr\_only\_onshell\_emitted\_partons}] Switch to
   allow only for on-shell emitted partons, thereby rejecting all
   possible final state parton showers starting from partons emitted
   during the ISR. (Default = false)
 \end{description}
 
 Settings for the \pythia\ are transferred using the following
 \sindarin\ variables:\\[2ex]
 \centerline{\begin{tabular}{|l|l|}
 \hline\ttt{?ps\_PYTHIA\_verbose} & if set to false, output from
 \pythia\ will be suppressed\\\hline
 \ttt{\$ps\_PYTHIA\_PYGIVE} & a string containing settings transferred
 to \pythia's \ttt{PYGIVE} subroutine.\\ & The format is explained in
 the \pythia\ manual. The limitation to 100 \\ & characters mentioned
 there does not apply here, the string is split \\ & appropriately
 before being transferred to \pythia.\\\hline
 \end{tabular}}\mbox{}
 
 \vspace{4mm}
 
 Note that the included version of \pythia\ uses \lhapdf\ for initial state
 radiation whenever this is available, but the PDF set has to be set
 manually in that case using the keyword \ttt{ps\_PYTHIA\_PYGIVE}.
 
 \subsection{Parton shower -- Matrix Element Matching}
 
 Along with the inclusion of the parton showers, \whizard\ includes an
 implementation of the MLM matching procedure. For a detailed
 description of the implemented steps see \cite{Kilian:2011ka}. The
 inclusion of MLM matching still demands some manual settings in the
 \sindarin\ file. For a given base process and a matching of $N$
 additional jets, all processes that can be obtained by attaching up to
 $N$ QCD splittings, either a quark emitting a gluon or a gluon
 splitting into two quarks ar two gluons, have to be manually specified
 as additional processes. These additional processes need to be
 included in the \ttt{simulate} statement along with the original
 process. The \sindarin\ variable \ttt{mlm\_nmaxMEjets} has to be
 set to the maximum number of additional jets $N$. Moreover additional
 cuts have to be specified for the additional processes.
 \begin{verbatim}
   alias quark = u:d:s:c
   alias antiq = U:D:S:C
   alias j = quark:antiq:g
 
   ?mlm_matching = true
   mlm_ptmin = 5 GeV
   mlm_etamax = 2.5
   mlm_Rmin = 1
 
   cuts = all Dist > mlm_Rmin [j, j]
          and all Pt > mlm_ptmin [j]
          and all abs(Eta) < mlm_etamax [j]
 \end{verbatim}
 Note that the variables \ttt{mlm\_ptmin}, \ttt{mlm\_etamax} and
 \ttt{mlm\_Rmin} are used by the matching routine. Thus, replacing the
 variables in the \ttt{cut} expression and omitting the assignment
 would destroy the matching procedure.
 
 The complete list of variables introduced to steer the matching procedure is as follows:
 \begin{description}
 \item[\ttt{?mlm\_matching\_active}] Master switch to enable MLM
   matching. (Default = false)
 \item[\ttt{mlm\_ptmin}] Minimal transverse momentum, also used in
   the definition of a jet
 \item[\ttt{mlm\_etamax}] Maximal absolute value of pseudorapidity
   $\eta$, also used in defining a jet
 \item[\ttt{mlm\_Rmin}] Minimal $\eta-\phi$ distance $R_{min}$
 \item[\ttt{mlm\_nmaxMEjets}] Maximum number of jets $N$
 \item[\ttt{mlm\_ETclusfactor}] Factor to vary the jet
   definition. Should be $\geq 1$ for complete coverage of phase
   space. (Default = 1)
 \item[\ttt{mlm\_ETclusminE}] Minimal energy in the variation of the
   jet definition
 \item[\ttt{mlm\_etaclusfactor}] Factor in the variation of the jet
   definition. Should be $\leq 1$ for complete coverage of phase
   space. (Default = 1)
 \item[\ttt{mlm\_Rclusfactor}] Factor in the variation of the jet
   definition. Should be $\ge 1$ for complete coverage of phase
   space. (Default = 1)
 \end{description}
 The variation of the jet definition is a tool to asses systematic
 uncertainties introduced by the matching procedure (See section 3.1 in
 \cite{Kilian:2011ka}).
 
 
 %%%%%%%%%
 
 \section{Rescanning and recalculating events}
 \label{sec:rescan}
 
 In the simplest mode of execution, \whizard\ handles its events at the
 point where they are generated.  It can apply event transforms such as
 decays or shower (see above), it can analyze the events, calculate and
 plot observables, and it can output them to file.  However, it is also
 possible to apply two different operations to those events in
 parallel, or to reconsider and rescan an event sample that has been
 previously generated.
 
 We first discuss the possibilities that \ttt{simulate} offers.  For
 each event, \whizard\ calculates the matrix element for the hard
 interaction, supplements this by Jacobian and phase-space factors in
 order to obtain the event weight, optionally applies a rejection step
 in order to gather uniformly weighted events, and applies the
 cuts and analysis setup.  We may ask about the event matrix element or
 weight, or the analysis result, that we would have obtained for a
 different setting.  To this end, there is an \ttt{alt\_setup} option.
 
 This option allows us to recalculate, event by event, the matrix
 element, weight, or analysis contribution with a different parameter
 set but identical kinematics.  For instance, we may evaluate a
 distribution for both zero and non-zero anomalous coupling \ttt{fw}
 and enter some observable in separate histograms:
 
 \begin{footnotesize}
 \begin{verbatim}
   simulate (some_proc) {
       fw = 0
       analysis = record hist1 (eval Pt [H])
     alt_setup = {
        fw = 0.01
        analysis = record hist2 (eval Pt [H])
     }
   }
 \end{verbatim}
 \end{footnotesize}
 
 In fact, the \ttt{alt\_setup} object is not restricted to a single
 code block (enclosed in curly braces) but can take a list of those,
 \begin{footnotesize}
 \begin{verbatim}
   alt_setup = { fw = 0.01 }, { fw = 0.02 }, ...
 \end{verbatim}
 \end{footnotesize}
 Each block provides the environment for a separate evaluation of the
 event data.  The generation of these events, i.e., their kinematics,
 is still steered by the primary environment.
 
 The \ttt{alt\_setup} blocks may modify various settings that affect the
 evaluation of an event, including physical parameters, PDF choice,
 cuts and analysis, output format, etc.  This must not (i.e., cannot)
 affect the kinematics of an event, so don't modify particle masses.
 When applying cuts, they can only reduce the generated event sample,
 so they apply on top of the primary cuts for the simulation.
 
 Alternatively, it is possible to \ttt{rescan} a sample that has been
 generated by a previous \ttt{simulate} command:
 \begin{footnotesize}
 \begin{verbatim}
   simulate (some_proc) { $sample = "my_events"
     analysis = record hist1 (eval Pt [H])
   }
   ?update_sqme = true
   ?update_weight = true
   rescan "my_events" (some_proc) {
     fw = 0.01
     analysis = record hist2 (eval Pt [H])
   }
   rescan "my_events" (some_proc) {
     fw = 0.05
     analysis = record hist3 (eval Pt [H])
   }
 \end{verbatim}
 \end{footnotesize}
 In more complicated situation, rescanning is more transparent and
 offers greater flexibility than doing all operations at the very point
 of event generation.
 
 Combining these features with the \ttt{scan} looping construct, we
 already cover a considerable range of applications.  (There are
 limitations due to the fact that \sindarin\ doesn't provide array
 objects, yet.)  Note that the \ttt{rescan} construct also allows
 for an \ttt{alt\_setup} option.
 
 You may generate a new sample by rescanning, for which you may choose
 any output format:
 \begin{footnotesize}
 \begin{verbatim}
   rescan "my_events" (some_proc) {
     selection = all Pt > 100 GeV [H]
     $sample = "new_events"
     sample_format = lhef
   }
 \end{verbatim}
 \end{footnotesize}
 
 The event sample that you rescan need not be an internal raw \whizard\
 file, as above.  You may rescan a LHEF file,
 \begin{footnotesize}
 \begin{verbatim}
   rescan "lhef_events" (proc) {
     $rescan_input_format = "lhef"
   }
 \end{verbatim}
 \end{footnotesize}
 This file may have any origin, not necessarily from \whizard.  To
 understand such an external file, \whizard\ must be able to
 reconstruct the hard process and match it to a process with a known
 name (e.g., \ttt{proc}), that has been defined in the \sindarin\ script
 previously.
 
 Within its limits, \whizard\ can thus be used for translating an event
 sample from one format to another format.
 
 There are three important switches that control the rescanning
 behavior.  They can be set or unset independently.
 \begin{itemize}
 \item \ttt{?update\_sqme} (default: false).
   If true, \whizard\ will recalculate the hard matrix element for each
   event.  When applying an analysis, the recalculated squared matrix
   element (averaged and summed over quantum numbers as usual) is
   available as the variable \ttt{sqme\_prc}.  This may be related to
   \ttt{sqme\_ref}, the corresponding
   value in the event file, if available.  (For the \ttt{alt\_env}
   option, this switch is implied.)
 \item \ttt{?update\_weight} (default: false).
   If true, \whizard\ will recalculate the event weight according to
   the current environment and apply this to the event.  In particular,
   the user may apply a \ttt{reweight} expression.  In an
   analysis, the new weight value is available as \ttt{weight\_prc}, to
   be related
   to \ttt{weight\_ref} from the sample.  The updated weight will be
   applied for histograms and averages.  An unweighted event sample
   will thus be transformed into a weighted event sample.  (This switch
   is also implied for the \ttt{alt\_env} option.)
 \item \ttt{?update\_event} (default: false).
   If true, \whizard\ will generate a new decay chain etc., if
   applicable.  That is, it reuses just the particles in the hard
   process.  Otherwise, the complete event is kept as it is written to
   file.
 \end{itemize}
 For these options to make sense, \whizard\ must have access to a full
 process object, so the \sindarin\ script must contain not just a
 definition but also a \ttt{compile} command for the matrix elements in
 question.
 
 If an event file (other than raw format) contains several processes as
 a mixture, they must be identifiable by a numeric ID.  \whizard\ will
 recognize the processes if their respective \sindarin\ definitions
 contain appropriate \ttt{process\_num\_id} options, such as
 \begin{footnotesize}
 \begin{verbatim}
   process foo = u, ubar => d, dbar { process_num_id = 42 }
 \end{verbatim}
 \end{footnotesize}
 
 Certain event-file formats, such as LHEF, support alternative
 matrix-element values or weights.  \whizard\ can thus write both
 original and
 recalculated matrix-element and weight values.
 Other formats support only a single
 event weight, so the \ttt{?update\_weight} option is necessary for a
 visible effect.
 
 External event files in formats such as LHEF, HepMC, or LCIO, also may
 carry information about the value of the strong coupling $\alpha_s$
 and the energy scale of each event.  This information will also be
 provided by \whizard\ when writing external event files.  When such an
 event file is rescanned, the user has the choice to either user the
 $\alpha_s$ value that \whizard\ defines in the current context (or the
 method for obtaining an event-specific running $\alpha_s$ value), or
 override this for each event by using the value in the event file.
 The corresponding parameter is \ttt{?use\_alphas\_from\_file}, which
 is false by default.  Analogously, the parameter
 \ttt{?use\_scale\_from\_file} may be set to override the scale
 definition in the current context.  Obviously, these settings
 influence matrix-element recalculation and therefore require
 \ttt{?update\_sqme} to be set in order to become operational.
 
 %%%%%%%%%
 
 \section{Negative weight events}
 For usage at NLO refer to Subsection~\ref{ss:fixedorderNLOevents}.
 In case, you have some other mechanism to produce events with negative
 weights (e.g. with the \ttt{weight = {\em <expr>}} command), keep in
 mind that you should activate \ttt{?negative\_weights = true} and
 \ttt{unweighted = false}.  The generation of unweighted events with
 varying sign (also known as events and counter events) is currently not
 supported.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{User Code Plug-Ins}
 \label{chap:user}
 
 {\color{red}
 Note that the user-code plug-in mechanism has been currently (for
 version 2.2.0) disabled, as the huge refactoring of the code between
 versions 2.1.X and 2.2.X has completely changed many of the
 interfaces. We plan to bring the interface for user code for spectra,
 structure functions and event shapes, cuts and observables back online
 as soon as possible, at latest for version 2.4.0.
 }
 
 \vspace{2cm}
 
 
 \section{The plug-in mechanism}
 
 The capabilities of \whizard\ and its \sindarin\ command
 language are not always sufficient to adapt to all users' needs.  To
 make the program more versatile, there are several spots in the
 workflow where the user may plug in his/her own code, to enhance or
 modify the default behavior.
 
 User code can be injected, without touching \whizard's source code, in
 the following places:
 \begin{itemize}
 \item
   Cuts, weights, analysis, etc.:
   \begin{itemize}
   \item
     Cut functions that operate on a whole subevent.
   \item
     Observable (e.g., event shapes) calculated from a whole subevent.
   \item
     Observable calculated for a particle or particle pair.
   \end{itemize}
 \item
   Spectra and structure functions.
 \end{itemize}
 Additional plug-in locations may be added in the future.
 
 User code is loaded dynamically by \whizard.  There are two
 possibilities:
 \begin{enumerate}
 \item
   The user codes the required procedures in one or more Fortran source
   files that are present in the working directory of the \whizard\
   program.  \whizard\ is called with the \ttt{-u} flag:
   \begin{quote}
     \ttt{whizard -u --user-src=\emph{user-source-code-file}} \ldots
   \end{quote}
   The file must have the extension \ttt{.f90}, and the file name must
   be specified without extension.
 
   There may be an arbitrary number of user source-code files.  The
   compilation is done in order of appearance.  If the name of the user
   source-code file is \ttt{user.f90}, the flag \ttt{--user-src} can
   be omitted.
 
   This tells the program to compile and dynamically link the code at
   runtime.  The basename of the linked library is \ttt{user}.
 
   If a compiled (shared) library with that name already exists, it is taken
   as-is.  If the
   user code changes or the library becomes invalid for other reasons,
   recompilation of the user-code files can be forced by the flag
   \ttt{--rebuild-user} or by the generic \ttt{-r} flag.
 \item
   The user codes and compiles the required procedures him/herself.
   They should be provided in form of a library, where the interfaces of
   the individual procedures follow C calling conventions and exactly
   match the required interfaces as described in the following
   sections.  The library must be compiled in such a way that it can be
   dynamically linked.  If the calling conventions are met, the actual
   user code may be written in any programming language.  E.g., it may
   be coded in Fortran, C, or C++ (with \ttt{extern(C)} specifications).
 
   \whizard\ is called with the \ttt{-u} flag and is
   given the name of the user library as
   \begin{quote}
     \ttt{whizard -u --user-lib=\emph{user-library-file}} \ldots
   \end{quote}
 \end{enumerate}
 The library file should either be a dynamically loadable (shared)
 library with appropriate extension (\ttt{.so} on Linux), or a libtool
 archive (\ttt{.la}).
 
 The user-provided procedures may have arbitrary names; the user just
 has to avoid clashes with procedures from the Fortran runtime library
 or from the operating-system environment.
 
 
 \section{Data Types Used for Communication}
 \label{sec:c_prt}
 
 Since the user-code interface is designed to be interoperable with C,
 it communicates with \whizard\ only via C-interoperable data types.
 The basic data types (Fortran: integer and real kinds) \ttt{c\_int}
 and \ttt{c\_double} are usually identical with the default kinds on
 the Fortran side.  If necessary, explicit conversion may be inserted.
 
 For transferring particle data, we are using a specific derived type
 \ttt{c\_prt\_t} which has the following content:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
   type, bind(C) :: c_prt_t
      integer(c_int) :: type
      integer(c_int) :: pdg
      integer(c_int) :: polarized
      integer(c_int) :: h
      real(c_double) :: pe
      real(c_double) :: px
      real(c_double) :: py
      real(c_double) :: pz
      real(c_double) :: p2
   end type c_prt_t
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 The meaning of the entries is as follows:
 \begin{description}
 \item[\ttt{type}:] The type of the particle.  The common type
   codes are 1=incoming, 2=outgoing, and 3=composite.  A composite
   particle in a subevent is created from a combination of individual
   particle momenta, e.g., in jet clustering.  If the status code is
   not defined, it is set to zero.
 \item[\ttt{pdg}:] The particle identification code as proposed by the
   Particle Data Group.  If undefined, it is zero.
 \item[\ttt{polarized}:] If nonzero, the particle is polarized.  The
   only polarization scheme supported at this stage is helicity.  If
   zero, particle polarization is ignored.
 \item[\ttt{h}:] If the particle is polarized, this is the helicity.  $0$
   for a scalar, $\pm 1$ for a spin-1/2 fermion, $-1,0,1$ for a spin-1
   boson.
 \item[\ttt{pe}:] The energy in GeV.
 \item[\ttt{px}/\ttt{py}:] The transversal momentum components in GeV.
 \item[\ttt{pz}:] The longitudinal momentum component in GeV.
 \item[\ttt{p2}:] The invariant mass squared of the actual momentum in GeV$^2$.
 \end{description}
 \whizard\ does not provide tools for manipulating \ttt{c\_prt\_t}
 objects directly.  However, the four-momentum can be used in
 Lorentz-algebra calculations from the \ttt{lorentz} module.  To this
 end, this module defines the transformational functions
 \ttt{vector4\_from\_c\_prt} and \ttt{vector4\_to\_c\_prt}.
 
 
 \section{User-defined Observables and Functions}
 \subsection{Cut function}
 Instead of coding a cut expression in \sindarin, it may be coded in
 Fortran, or in any other language with a C-compatible interface.  A
 user-defined cut expression is referenced in \sindarin\ as follows:
 \begin{quote}
 \begin{footnotesize}
   \ttt{cuts = user\_cut (\emph{name-string}) [\emph{subevent}]}
 \end{footnotesize}
 \end{quote}
 The \ttt{\emph{name-string}} is an expression that evaluates to
 string, the name of the function to call in the user code.  The
 \emph{subevent} is a subevent expression, analogous to the built-in
 cut definition syntax.  The result of the \ttt{user\_cut} function is
 a logical value in \sindarin.  It is true if the event passes the cut,
 false otherwise.
 
 If coded in Fortran, the actual user-cut function in the user-provided
 source code has the following form:
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 function user_cut_fun (prt, n_prt) result (iflag) bind(C)
    use iso_c_binding
    use c_particles
    type(c_prt_t), dimension(*), intent(in) :: prt
    integer(c_int), intent(in) :: n_prt
    integer(c_int) :: iflag
    ! ... code that evaluates iflag
 end function user_cut_fun
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 Here, \ttt{user\_cut\_fun} can be replaced by an arbitrary name by
 which the function is referenced as \ttt{\emph{name-string}} above.
 The \ttt{bind(C)} attribute in the function declaration is mandatory.
 
 The argument \ttt{prt} is an array of objects of type \ttt{c\_prt\_t},
 as described above.  The integer \ttt{n\_prt} is the number of entries
 in the array.  It is passed separately in order to determine the
 actual size of the assumed-size \ttt{prt} array.
 
 The result \ttt{iflag} is an integer.  A nonzero value indicates
 \ttt{true} (i.e., the event passes the cut), zero value indicates
 \ttt{false}.  (We do not use boolean values in the interface because
 their interoperability might be problematic on some systems.)
 
 \subsection{Event-shape function}
 
 An event-shape function is similar to a cut function.  It takes a
 subevent as argument and returns a real (i.e., C double) variable.  It
 can be used for defining subevent observables, event weights, or the
 event scale, as in
 \begin{quote}
 \begin{footnotesize}
   \ttt{analysis = record \emph{hist-id} (user\_event\_fun (\emph{name-string}) [\emph{subevent}])}
 \end{footnotesize}
 \end{quote}
 or
 \begin{quote}
 \begin{footnotesize}
   \ttt{scale = user\_event\_fun (\emph{name-string}) [\emph{subevent}]}
 \end{footnotesize}
 \end{quote}
 The corresponding Fortran source code has the form
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 function user_event_fun (prt, n_prt) result (rval) bind(C)
    use iso_c_binding
    use c_particles
    type(c_prt_t), dimension(*), intent(in) :: prt
    integer(c_int), intent(in) :: n_prt
    real(c_double) :: rval
    ! ... code that evaluates rval
 end function user_event_fun
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 with \ttt{user\_event\_fun} replaced by \ttt{\emph{name-string}}.
 
 \subsection{Observable}
 
 In \sindarin, an observable-type function is a function of one or two
 particle objects that returns a real value.  The particle objects
 result from scanning over subevents.  In the \sindarin\ code, the
 observable is used like a variable; the particle-object arguments are
 implictly assigned.
 
 A user-defined observable is used analogously, e.g.,
 \begin{quote}
 \begin{footnotesize}
   \ttt{cuts = all user\_obs (\emph{name-string}) > 0 [\emph{subevent}]}
 \end{footnotesize}
 \end{quote}
 The user observable is defined, as Fortran code, as either a unary or
 as a binary C-double-valued function of \ttt{c\_prt\_t} objects.  The
 use in \sindarin\ (unary or binary) must match the definition.
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 function user_obs_unary (prt1) result (rval) bind(C)
   use iso_c_binding
   use c_particles
   type(c_prt_t), intent(in) :: prt1
   real(c_double) :: rval
   ! ... code that evaluates rval
 end function user_obs_unary
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 or
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 function user_obs_binary (prt1, prt2) result (rval) bind(C)
   use iso_c_binding
   use c_particles
   type(c_prt_t), intent(in) :: prt1, prt2
   real(c_double) :: rval
   ! ... code that evaluates rval
 end function user_obs_binary
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 with \ttt{user\_obs\_unary}/\ttt{binary} replaced by
 \ttt{\emph{name-string}}.
 
 \subsection{Examples}
 
 For an example, we implement three different ways of computing the
 transverse momentum of a particle.  This observable is actually
 built into \whizard, so the examples are not particularly useful.  However,
 implementing kinematical functions that are not supported (yet) by
 \whizard\ (and not easily computed via \sindarin\ expressions)
 proceeds along the same lines.
 
 \subsubsection{Cut}
 The first function is a complete cut which can be used as
 \begin{quote}
   \begin{footnotesize}
     \ttt{cuts = user\_cut("ptcut") [\emph{subevt}]}
   \end{footnotesize}
 \end{quote}
 It is equivalent to
 \begin{quote}
   \begin{footnotesize}
     \ttt{cuts = all Pt $>$ 50 [\emph{subevt}]}
   \end{footnotesize}
 \end{quote}
 The implementation reads
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 function ptcut (prt, n_prt) result (iflag) bind(C)
   use iso_c_binding
   use c_particles
   use lorentz
   type(c_prt_t), dimension(*), intent(in) :: prt
   integer(c_int), intent(in) :: n_prt
   integer(c_int) :: iflag
   logical, save :: first = .true.
   if (all (transverse_part (vector4_from_c_prt (prt(1:n_prt))) > 50)) then
      iflag = 1
   else
      iflag = 0
   end if
 end function ptcut
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 The procedure makes use of the kinematical functions in the
 \ttt{lorentz} module, after transforming the particles into a
 \ttt{vector4} array.
 
 \subsubsection{Event Shape}
 Similar functionality can be achieved by implementing an event-shape
 function.  The function computes the minimum $p_T$ among all particles
 in the subevent.  The \sindarin\ expression reads
 \begin{quote}
   \begin{footnotesize}
     \ttt{cuts = user\_event\_shape("pt\_min") [\emph{subevt}] $>$ 50}
   \end{footnotesize}
 \end{quote}
 and the function is coded as
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 function pt_min (prt, n_prt) result (rval) bind(C)
   use iso_c_binding
   use c_particles
   use lorentz
   type(c_prt_t), dimension(*), intent(in) :: prt
   integer(c_int), intent(in) :: n_prt
   real(c_double) :: rval
   rval = minval (transverse_part (vector4_from_c_prt (prt(1:n_prt))))
 end function pt_min
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 
 \subsubsection{Observable}
 The third (and probably simplest) user implementation of the $p_T$ cut
 computes a single-particle observable.  Here, the usage is
 \begin{quote}
   \begin{footnotesize}
     \ttt{cuts = all user\_obs("ptval") $>$ 50 [\emph{subevt}]}
   \end{footnotesize}
 \end{quote}
 and the subroutine reads
 \begin{quote}
 \begin{footnotesize}
 \begin{verbatim}
 function ptval (prt1) result (rval) bind(C)
   use iso_c_binding
   use c_particles
   use lorentz
   type(c_prt_t), intent(in) :: prt1
   real(c_double) :: rval
   rval = transverse_part (vector4_from_c_prt (prt1))
 end function ptval
 \end{verbatim}
 \end{footnotesize}
 \end{quote}
 
 \section{User Code and Static Executables}
 
 In Sec.~\ref{sec:static} we describe how to build a static executable that can
 be submitted to batch jobs, e.g., on the grid, where a compiler may not be
 available.
 
 If there is user plug-in code, it would require the same setup of
 libtool, compiler and linker on the target host, as physical process
 code.  To avoid this, it is preferable to link the user code
 statically with the executable, which is then run as a monolithic
 program.
 
 This is actually simple.  Two conditions have to be met:
 \begin{enumerate}
 \item
   The \whizard\ job that creates the executable has to be given the appropriate
   options (\ttt{-u}, \ttt{--user-src}, \ttt{--user-lib}) such that
   the user code is dynamically compiled and linked.
 \item
   The compile command in the \sindarin\ script which creates the
   executable takes options that list the procedures which the
   stand-alone program should access:
   \begin{quote}
     \begin{footnotesize}
 \ttt{%
 compile as "\emph{executable-name}" \{ \\
 \hspace*{2em}  \$user\_procs\_cut          = "\emph{cut-proc-names}"\\
 \hspace*{2em}  \$user\_procs\_event\_shape = "\emph{event-shape-proc-names}"\\
 \hspace*{2em}  \$user\_procs\_obs1         = "\emph{obs1-proc-names}"\\
 \hspace*{2em}  \$user\_procs\_obs2         = "\emph{obs2-proc-names}"\\
 \hspace*{2em}  \$user\_procs\_sf           = "\emph{strfun-names}"\\
 \}}
     \end{footnotesize}
   \end{quote}
   The values of these option variables are comma-separated lists of procedure
   names, grouped by their nature.  \ttt{obs1} and \ttt{obs2} refer to unary
   and binary observables, respectively.  The \ttt{strfun-names} are
   the names of the user-defined spectra or structure functions as they
   would appear in the \sindarin\ file which uses them.
 \end{enumerate}
 With these conditions met, the stand-alone executable will have the
 user code statically linked, and it will be able to use exactly those
 user-defined routines that have been listed in the various option
 strings.  (It is possible nevertheless, to plug in additional user code
 into the stand-alone executable, using the same options as for the
 original \whizard\ program.)
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{Data Visualization}
 \label{chap:visualization}
 
 \section{GAMELAN}
 
 The data values and tables that we have introduced in the previous section can
 be visualized using built-in features of \whizard.  To be precise,
 \whizard\ can write \LaTeX\ code which incorporates code in the graphics
 language GAMELAN to produce a pretty-printed account of observables,
 histograms, and plots.
 
 GAMELAN is a macro package for MetaPost, which is part of the
 \TeX/\LaTeX\ family.  MetaPost, a derivative of Knuth's MetaFont language for
 font design, is usually bundled with the \TeX\ distribution, but might need a
 separate switch for installation.  The GAMELAN macros are contained in a
 subdirectory of the \whizard\ package.  Upon installation, they will be
 installed in the appropriate directory, including the \ttt{gamelan.sty} driver
 for \LaTeX.  \whizard\ uses a subset of GAMELAN's graphics macros
 directly, but it allows for access to the full package if desired.
 
 An (incomplete) manual for GAMELAN can be found in the \ttt{share/doc}
 subdirectory of the \whizard\ system.  \whizard\ itself uses a subset of the
 GAMELAN capabilities, interfaced by \sindarin\ commands and parameters.  They
 are described in this chapter.
 
 To process analysis output beyond writing tables to file, the
 \ttt{write\_analysis} command described in the previous section should be
 replaced by \ttt{compile\_analysis}, with the same syntax:
 \begin{quote}
   \begin{footnotesize}
     \ttt{compile\_analysis (\emph{analysis-tags}) \{ \ttt{\emph{options}} \}}
   \end{footnotesize}
 \end{quote}
 where \ttt{\emph{analysis-tags}}, a comma-separated list of analysis objects,
 is optional.  If there are no tags, all analysis objects are processed.  The
 \ttt{\emph{options}} script of local commands is also optional, of course.
 
 This command will perform the following actions:
 \begin{enumerate}
 \item
   It writes a data file in default format, as \ttt{write\_analysis} would do.
   The file name is given by \ttt{\$out\_file}, if nonempty.  The file must not
   be already open, since the command needs a self-contained file, but the name
   is otherwise arbitrary.  If the value of \ttt{\$out\_file} is empty, the
   default file name is \ttt{whizard\_analysis.dat}.
 \item
   It writes a driver file for the chosen datasets, whose name is derived from
   the data file by replacing the file extension of the data file with the
   extension \ttt{.tex}.  The driver file is a \LaTeX\ source file which
   contains embedded GAMELAN code that handles the selected graphics data.  In
   the \LaTeX\ document, there is a separate section for each contained
   dataset. Furthermore, a process-/analysis-specific makefile with the
   name \ttt{<process\_name>\_ana.makefile} is created that can be used
   to generate postscript or PDF output from the \LaTeX\ source. If the
   steering flag \ttt{?analysis\_file\_only} is set to \ttt{true}, then
   the \LaTeX\ file and the makefile are only written, but no execution
   of the makefile resulting in compilation of the \LaTeX\ code (see
   the next item) is invoked.
 \item
   As mentioned above, if the flag \ttt{?analysis\_file\_only} is set
   to \ttt{false} (which is the default), the driver file is processed
   by \LaTeX (invoked by calling the makefile with the name
   \ttt{<process\_name>\_ana.makefile}), which generates an appropriate
   GAMELAN source file with extension \ttt{.mp}.  This code is executed
   (calling GAMELAN/MetaPost, and again \LaTeX\ for typesetting embedded
   labels).  There is a second \LaTeX\ pass (automatically done by the
   makefile) which collects the results, and finally conversion to
   PostScript and PDF formats.
 \end{enumerate}
 
 The resulting PostScript or PDF file -- the file name is the name of the data
 file with the extension replaced by \ttt{.ps} or \ttt{.pdf}, respectively
 -- can be printed or viewed with an appropriate viewer such as \ttt{gv}.  The
 viewing command is not executed automatically by \whizard.
 
 Note that \LaTeX\ will write further files with extensions \ttt{.log},
 \ttt{.aux}, and \ttt{.dvi}, and GAMELAN will produce auxiliary files with
 extensions \ttt{.ltp} and \ttt{.mpx}. The log file in particular, could
 overwrite \whizard's log file if the basename is identical.  Be careful to use
 a value for \ttt{\$out\_file} which is not likely to cause name clashes.
 
 
 \subsection{User-specific changes}
 
 In the case, that the \sindarin\ \ttt{compile\_analysis} command is
 invoked and the flag named \ttt{?analysis\_file\_only} is not changed
 from its default value \ttt{false}, \whizard\ calls the
 process-/analysis-specific makefile triggering the compilation of the
 \LaTeX\ code and the GAMELAN plots and histograms. If the user wants
 to edit the analysis output, for example changing captions, headlines,
 labels, properties of the plots, graphs and histograms using GAMELAN
 specials etc., this is possible and the output can be regenerated
 using the makefile. The user can also directly invoke the GAMELAN
 script, \ttt{whizard-gml}, that is installed in the binary directly
 along with the \whizard\ binary and other scripts. Note however, that
 the \LaTeX\ environment for the specific style files have to be set by
 hand (the command line invocation in the makefile does this
 automatically). Those style files are generally written into
 \ttt{share/texmf/whizard/} directory. The user can execute the
 commands in the same way as denoted in the process-/analysis-specific
 makefile by hand.
 
 
 %%%%%
 
 \section{Histogram Display}
 
 
 %%%%%
 
 \section{Plot Display}
 
 
 \section{Graphs}
 \label{sec:graphs}
 
 Graphs are an additional type of analysis object.  In contrast to histograms
 and plots, they do not collect data directly, but they rather act as
 containers for graph elements, which are copies of existing histograms and
 plots.  Their single purpose is to be displayed by the GAMELAN driver.
 
 Graphs are declared by simple assignments such as
 \begin{quote}
   \begin{footnotesize}
     \ttt{graph g1 = hist1}
 \\
     \ttt{graph g2 = hist2 \& hist3 \& plot1}
   \end{footnotesize}
 \end{quote}
 The first declaration copies a single histogram into the graph, the second one
 copies two histograms and a plot.  The syntax for collecting analysis objects
 uses the \ttt{\&} concatenation operator, analogous to string concatenation.
 In the assignment, the rhs must contain only histograms and plots.  Further
 concatenating previously declared graphs is not supported.
 
 After the graph has been declared, its contents can be written to file
 (\ttt{write\_analysis}) or, usually, compiledd by the \LaTeX/GAMELAN driver
 via the \ttt{compile\_analysis} command.
 
 The graph elements on the right-hand side of the graph assignment are copied
 with their current data content.  This implies a well-defined order of
 statements: first, histograms and plots are declared, then they are filled via
 \ttt{record} commands or functions, and finally they can be collected for
 display by graph declarations.
 
 A simple graph declaration without options as above is possible, but usually
 there are option which affect the graph display.  There are two kinds of
 options: graph options and drawing options.  Graph options apply to the graph
 as a whole (title, labels, etc.) and are placed in braces on the lhs of the
 assigment.  Drawing options apply to the individual graph elements
 representing the contained histograms and plots, and are placed together with
 the graph element on the rhs of the assignment.  Thus, the complete syntax for
 assigning multiple graph elements is
 \begin{quote}
   \begin{footnotesize}
     \ttt{graph \emph{graph-tag} \{ \emph{graph-options} \}}
 \\
     \ttt{= \emph{graph-element-tag1} \{ \emph{drawing-options1} \}}
 \\
     \ttt{\& \emph{graph-element-tag2} \{ \emph{drawing-options2} \}}
 \\
      \ldots
   \end{footnotesize}
 \end{quote}
 This form is recommended, but graph and drawing options can also be set as
 global parameters, as usual.
 
 We list the supported graph and drawing options in
 Tables~\ref{tab:graph-options} and \ref{tab:drawing-options}, respectively.
 
 \begin{table}
   \caption{Graph options.  The content of strings of type \LaTeX\ must be
     valid \LaTeX\ code (containing typesetting commands such as math mode).
     The content of strings of type GAMELAN must be valid GAMELAN code.
     If a graph bound is kept \emph{undefined}, the actual graph bound is
     determined such as not to crop the graph contents in the selected
     direction.}
   \label{tab:graph-options}
 
   \begin{center}
     \begin{tabular}{|l|l|l|l|}
       \hline
       Variable & Default & Type & Meaning
       \\
       \hline\hline
       \ttt{\$title}  & \ttt{""} & \LaTeX &
         Title of the graph = subsection headline
       \\
       \hline
       \ttt{\$description}  & \ttt{""} &  \LaTeX &
         Description text for the graph
       \\
       \hline
       \ttt{\$x\_label} & \ttt{""} & \LaTeX &
         $x$-axis label
       \\
       \hline
       \ttt{\$y\_label} & \ttt{""} & \LaTeX &
         $y$-axis label
       \\
       \hline
       \ttt{graph\_width\_mm} & 130 & Integer &
         graph width (on paper) in mm
       \\
       \hline
       \ttt{graph\_height\_mm} & 90 & Integer &
         graph height (on paper) in mm
       \\
       \hline
       \ttt{?x\_log} & false & Logical &
         Whether the $x$-axis scale is linear or logarithmic
       \\
       \hline
       \ttt{?y\_log} & false & Logical &
         Whether the $y$-axis scale is linear or logarithmic
       \\
       \hline
       \ttt{x\_min} & \emph{undefined} & Real &
         Lower bound for the $x$ axis
       \\
       \hline
       \ttt{x\_max} & \emph{undefined} & Real &
         Upper bound for the $x$ axis
       \\
       \hline
       \ttt{y\_min} & \emph{undefined} & Real &
         Lower bound for the $y$ axis
       \\
       \hline
       \ttt{y\_max} & \emph{undefined} & Real &
         Upper bound for the $y$ axis
       \\
       \hline
       \ttt{gmlcode\_bg} & \ttt{""} & GAMELAN &
          Code to be executed before drawing
       \\
       \hline
       \ttt{gmlcode\_fg} & \ttt{""} & GAMELAN &
          Code to be executed after drawing
       \\
       \hline
     \end{tabular}
   \end{center}
 \end{table}
 
 \begin{table}
   \caption{Drawing options.  The content of strings of type GAMELAN must be
     valid GAMELAN code.  The behavior w.r.t. the flags with \emph{undefined}
     default value depends on the type of graph element.  Histograms: draw
     baseline, piecewise, fill area, draw curve, no errors, no symbols;  Plots:
     no baseline, no fill, draw curve, no errors, no symbols.}
   \label{tab:drawing-options}
 
   \begin{center}
     \begin{tabular}{|l|l|l|l|}
       \hline
       Variable & Default & Type & Meaning
       \\
       \hline\hline
       \ttt{?draw\_base}  & \emph{undefined} & Logical &
         Whether to draw a baseline for the curve
       \\
       \hline
       \ttt{?draw\_piecewise}  & \emph{undefined} & Logical &
         Whether to draw bins separately (histogram)
       \\
       \hline
       \ttt{?fill\_curve}  & \emph{undefined} & Logical &
         Whether to fill area between baseline and curve
       \\
       \hline
       \ttt{\$fill\_options} & \ttt{""} & GAMELAN &
         Options for filling the area
       \\
       \hline
       \ttt{?draw\_curve} & \emph{undefined} & Logical &
         Whether to draw the curve as a line
       \\
       \hline
       \ttt{\$draw\_options} & \ttt{""} & GAMELAN &
         Options for drawing the line
       \\
       \hline
       \ttt{?draw\_errors} & \emph{undefined} & Logical &
         Whether to draw error bars for data points
       \\
       \hline
       \ttt{\$err\_options} & \ttt{""} & GAMELAN &
         Options for drawing the error bars
       \\
       \hline
       \ttt{?draw\_symbols} & \emph{undefined} & Logical &
         Whether to draw symbols at data points
       \\
       \hline
       \ttt{\$symbol} & Black dot & GAMELAN &
         Symbol to be drawn
       \\
       \hline
       \ttt{gmlcode\_bg} & \ttt{""} & GAMELAN &
          Code to be executed before drawing
       \\
       \hline
       \ttt{gmlcode\_fg} & \ttt{""} & GAMELAN &
          Code to be executed after drawing
       \\
       \hline
     \end{tabular}
   \end{center}
 \end{table}
 
 
 \section{Drawing options}
 
 The options for coloring lines, filling curves, or choosing line styles make
 use of macros in the GAMELAN language.  At this place, we do not intend to
 give a full account of the possiblities, but we rather list a few basic
 features that are likely to be useful for drawing graphs.
 
 
 \subsubsection{Colors}
 
 GAMELAN knows about basic colors identified by name:
 \begin{center}
   \ttt{black}, \ttt{white}, \ttt{red}, \ttt{green}, \ttt{blue}, \ttt{cyan},
   \ttt{magenta}, \ttt{yellow}
 \end{center}
 More generically, colors in GAMELAN are RGB triplets of numbers (actually,
 numeric expressions) with values between 0 and 1, enclosed in brackets:
 \begin{center}
   \ttt{(\emph{r}, \emph{g}, \emph{b})}
 \end{center}
 
 To draw an object in color, one should apply the construct \ttt{withcolor
   \emph{color}} to its drawing code.  The default color is always black.
 Thus, this will make a plot drawn in blue:
 \begin{quote}
   \begin{footnotesize}
     \ttt{\$draw\_options = "withcolor blue"}
   \end{footnotesize}
 \end{quote}
 and this will fill the drawing area of some histogram with an RGB color:
 \begin{quote}
   \begin{footnotesize}
     \ttt{\$fill\_options = "withcolor (0.8, 0.7, 1)"}
   \end{footnotesize}
 \end{quote}
 
 
 \subsubsection{Dashes}
 
 By default, lines are drawn continuously.  Optionally, they can be drawn using
 a \emph{dash pattern}.  Predefined dash patterns are
 \begin{center}
   \ttt{evenly}, \ttt{withdots}, \ttt{withdashdots}
 \end{center}
 Going beyond the predefined patterns, a generic dash pattern has the syntax
 \begin{center}
   \ttt{dashpattern (on \emph{l1} off \emph{l2} on} \ldots \ttt{)}
 \end{center}
 with an arbitrary repetition of \ttt{on} and \ttt{off} clauses.  The numbers
 \ttt{\emph{l1}}, \ttt{\emph{l2}}, \ldots\ are lengths measured in pt.
 
 To apply a dash pattern, the option syntax \ttt{dashed \emph{dash-pattern}}
 should be used.  Options strings can be concatenated.  Here is how to draw in
 color with dashes:
 \begin{quote}
   \begin{footnotesize}
     \ttt{\$draw\_options = "withcolor red dashed evenly"}
   \end{footnotesize}
 \end{quote}
 and this draws error bars consisting of intermittent dashes and
 dots:
 \begin{quote}
   \begin{footnotesize}
     \ttt{\$err\_options = "dashed (withdashdots scaled 0.5)"}
   \end{footnotesize}
 \end{quote}
 The extra brackets ensure that the scale factor $1/2$ is applied only the dash
 pattern.
 
 
 \subsubsection{Hatching}
 
 Areas (e.g., below a histogram) can be filled with plain colors by the
 \ttt{withcolor} option.  They can also be hatched by stripes, optionally
 rotated by some angle.  The syntax is completely analogous to dashes.  There
 are two predefined \emph{hatch patterns}:
 \begin{center}
    \ttt{withstripes}, \ttt{withlines}
 \end{center}
 and a generic hatch pattern is written
 \begin{center}
   \ttt{hatchpattern (on \emph{w1} off \emph{w2} on} \ldots \ttt{)}
 \end{center}
 where the numbers \ttt{\emph{l1}}, \ttt{\emph{l2}}, \ldots\ determine the
 widths of the stripes, measured in pt.
 
 When applying a hatch pattern, the pattern may be rotated by some angle (in
 degrees) and scaled.  This looks like
 \begin{quote}
   \begin{footnotesize}
     \ttt{\$fill\_options = "hatched (withstripes scaled 0.8 rotated 60)"}
   \end{footnotesize}
 \end{quote}
 
 
 \subsubsection{Smooth curves}
 
 Plot points are normally connected by straight lines.  If data are acquired by
 statistical methods, such as Monte Carlo integration, this is usually
 recommended.  However, if a plot is generated using an analytic mathematical
 formula, or with sufficient statistics to remove fluctuations, it might be
 appealing to connect lines by some smooth interpolation.  GAMELAN can switch
 on spline interpolation by the specific drawing option \ttt{linked smoothly}.
 Note that the results can be surprising if the data points do have sizable
 fluctuations or sharp kinks.
 
 
 \subsubsection{Error bars}
 
 Plots and histograms can be drawn with error bars.  For histograms, only
 vertical error bars are supported, while plot points can have error bars in
 $x$ and $y$ direction.  Error bars are switched on by the \ttt{?draw\_errors}
 flag.
 
 There is an option to draw error bars with ticks: \ttt{withticks} and an
 alternative option to draw arrow heads: \ttt{witharrows}.  These can be used
 in the \ttt{\$err\_options} string.
 
 
 \subsubsection{Symbols}
 
 To draw symbols at plot points (or histogram midpoints), the flag
 \ttt{?draw\_symbols} has to be switched on.
 
 
 
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \chapter{User Interfaces for WHIZARD}
 \label{chap:userint}
 
 \section{Command Line and \sindarin\ Input Files}
 \label{sec:cmdline-options}
 
 The standard way of using \whizard\ involves a command script written
 in \sindarin.  This script is executed by \whizard\ by mentioning it
 on the command line:
 \begin{interaction}
   whizard script-name.sin
 \end{interaction}
 You may specify several script files on the command line; they will be
 executed consecutively.
 
 If there is no script file, \whizard\ will read commands from standard
 input.  Hence, this is equivalent:
 \begin{interaction}
   cat script-name.sin | whizard
 \end{interaction}
 
 When executed from the command line, \whizard\ accepts several options.
 They are given in long form, i.e., they begin with two dashes.  Values
 that belong to options follow the option string, separated either by
 whitespace or by an equals sign.  Hence, \ttt{--prefix /usr} and
 \ttt{--prefix=/usr} are equivalent.  Some options are also available
 in short form, a single dash with a single letter.  Short-form options
 can be concatenated, i.e., a dash followed by several option letters.
 
 The first set of options is intended for normal operation.
 \begin{description}
 \item[\ttt{--debug AREA}]: Switch on debug output for \ttt{AREA}.
   \ttt{AREA} can be one of \whizard's source directories or \ttt{all}.
 \item[\ttt{--debug2 AREA}]: Switch on more verbose debug output for \ttt{AREA}.
 \item[\ttt{--single-event}]: Only compute one phase-space point (for debugging).
 \item[\ttt{--execute COMMANDS}]:  Execute \ttt{COMMANDS} as a script
   before the script file.  Short version: \ttt{-e}
 \item[\ttt{--help}]:  List the available options and exit.  Short version:
   \ttt{-h}
 \item[\ttt{--interactive}]:  Run \whizard\ interactively.  See
   Sec.~\ref{sec:whish}.  Short version: \ttt{-i}.
 \item[\ttt{--library LIB}]:  Preload process library \ttt{LIB}
   (instead of the default \ttt{processes}).  Short version: \ttt{-l}.
 \item[\ttt{--localprefix DIR}]:  Search in \ttt{DIR} for local
   models.  Default is \ttt{\$HOME/.whizard}.
 \item[\ttt{--logfile \ttt{FILE}}]: Write log to \ttt{FILE}.  Default is
   \ttt{whizard.log}.  Short version: \ttt{-L}.
 \item[\ttt{--logging}]: Start logging on startup (default).
 \item[\ttt{--model MODEL}]: Preload model \ttt{MODEL}.  Default is the
   Standard Model \ttt{SM}.  Short version: \ttt{-m}.
 \item[\ttt{--no-banner}]: Do not display banner at startup.
 \item[\ttt{--no-library}]: Do not preload a library.
 \item[\ttt{--no-logfile}]: Do not write a logfile.
 \item[\ttt{--no-logging}]: Do not issue information into the logfile.
 \item[\ttt{--no-model}]: Do not preload a specific physics model.
 \item[\ttt{--no-rebuild}]: Do not force a rebuild.
 \item[\ttt{--query VARIABLE}]: Display documentation of \ttt{VARIABLE}.
   Short version: \ttt{-q}.
 \item[\ttt{--rebuild}]: Do not preload a process library and do all
   calculations from scratch, even if results exist.  This combines all
   rebuild options.  Short version: \ttt{-r}.
 \item[\ttt{--rebuild-library}]: Rebuild the process library, even if code
   exists.
 \item[\ttt{--rebuild-phase-space}]: Rebuild the phase space setup, even if
   it exists.
 \item[\ttt{--rebuild-grids}]: Redo the integration, even if previous grids
   and results exist.
 \item[\ttt{--rebuild-events}]: Redo event generation, discarding previous
   event files.
 \item[\ttt{--show-config}]: Show build-time configuration.
 \item[\ttt{--version}]: Print version information and exit.  Short version:
   \ttt{-V}.
 \item[-]: Any further options are interpreted as file names.
 \end{description}
 The second set of options refers to the configuration.  They are
 relevant when dealing with a relocated \whizard\ installation, e.g.,
 on a batch systems.
 \begin{description}
 \item[\ttt{--prefix DIR}]: Specify the actual location of the \whizard\
   installation, including all subdirectories.
 \item[\ttt{--exec-prefix DIR}]:  Specify the actual location of the
   machine-specific parts of the \whizard\ installation (rarely needed).
 \item[\ttt{--bindir DIR}]:  Specify the actual location of the
   executables contained in the \whizard\ installation (rarely needed).
 \item[\ttt{--libdir DIR}]:  Specify the actual location of the
   libraries contained in the \whizard\ installation (rarely needed).
 \item[\ttt{--includedir DIR}]:  Specify the actual location of the
   include files contained in the \whizard\ installation (rarely needed).
 \item[\ttt{--datarootdir DIR}]:  Specify the actual location of the
   data files contained in the \whizard\ installation (rarely needed).
 \item[\ttt{--libtool LOCAL\_LIBTOOL}]:  Specify the actual location and
   name of the \ttt{libtool} script that should be used by \whizard.
 \item[\ttt{--lhapdfdir DIR}]:  Specify the actual location and
   of the \lhapdf\ installation that should be used by \whizard.
 \end{description}
 
 
 
 \section{WHISH -- The \whizard\ Shell/Interactive mode}
 \label{sec:whish}
 
 \whizard\ can be also run in the interactive mode using its own shell
 environment. This is called the \whizard\ Shell (WHISH). For this
 purpose, one starts with the command
 \begin{interaction}
   /home/user$ whizard --interactive
 \end{interaction}
 or
 \begin{interaction}
   /home/user$ whizard -i
 \end{interaction}
 \whizard\ will preload the Standard Model and display a command
 prompt:
 \begin{interaction}
   whish?
 \end{interaction}
 You now can enter one or more \sindarin\ commands, just as if they
 were contained in a script file.  The commands are compiled and
 executed after you hit the ENTER key.  When done, you get a new
 prompt.  The WHISH can be closed by the \ttt{quit} command:
 \begin{verbatim}
   whish? quit
 \end{verbatim}
 Obviously, each input must be self-contained: commands must be
 complete, and conditionals or scans must be closed on the same line.
 
 If \whizard\ is run without options and without a script file, it
 also reads commands interactively, from standard input.  The
 difference is that in this case, interactive input is multi-line,
 terminated by \ttt{Ctrl-D}, the script is then compiled and
 executed as a whole, and \whizard\ terminates.
 
 In WHISH mode, each input line is compiled and executed individually.
 Furthermore, fatal errors are masked, so in case of error the program
 does not terminate but returns to the WHISH command line.  (The
 attempt to recover may fail in some circumstances, however.)
 
 
 \section{Graphical user interface}
 
 \emph{This is still experimental.}
 
 \whizard\ ships with a graphical interface that can be steered in a
 browser of your choice. It is located in \ttt{share/gui}.  To use it,
 you have to run \ttt{npm install} (which will install javascript
 libraries locally in that folder) and \ttt{npm start} (which will start
 a local web server on your machine) in that folder.  More technical
 details and how to get \ttt{npm} is discussed in
 \ttt{share/gui/README.md}.  When it is running, you can access the GUI
 by entering \ttt{localhost:3000} as address in your browser.  The GUI is
 separated into different tabs for basic settings, integration,
 simulation, cuts, scans, NLO and beams.  You can select and enter what
 you are interested in and the GUI will produce a \sindarin\ file.  You
 can use the GUI to run WHIZARD with that \sindarin\ or just produce it
 with the GUI and then tweak it further with an editor.  In case you run
 it in the GUI, the log file will be updated in the browser as it is
 produced.  Any \sindarin\ features that are not supported by the GUI can
 be added directly as "Additional Code".
 
 \section{WHIZARD as a library}
 
 \emph{This is planned, but not implemented yet.}
 %%%%%
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \chapter{Examples}
 \label{chap:examples}
 
 In this chapter we discuss the running and steering of \whizard\ with
 the help of several examples. These examples can be found in the
 \ttt{share/examples} directory of your installation. All of these
 examples are also shown on the \whizard\ Wiki page:
 \url{https://whizard.hepforge.org/trac/wiki}.
 
 
 \section{$Z$ lineshape at LEP I}
 
 By this example, we demonstrate how a scan over collision energies
 works, using as example the measurement of the $Z$ lineshape at LEP I
 in 1989. The \sindarin\ script for this example, \ttt{Z-lineshape.sin}
 can be found in the \ttt{share/examples} folder of the \whizard\
 installation.
 
 We first use the Standard model as physics model:
 \begin{code}
 model = SM
 \end{code}
 Aliases for electron, muon and their antiparticles as leptons and
 those including the photon as particles in general are introduced:
 \begin{code}
 alias lep = e1:E1:e2:E2
 alias prt = lep:A
 \end{code}
 Next, the two processes are defined, \eemm, and the same with an
 explicit QED photon: $e^+e^- \to \mu^+\mu^-\gamma$,
 \begin{code}
 process bornproc = e1, E1 => e2, E2
 process rc = e1, E1 => e2, E2, A
 compile
 \end{code}
 and the processes are compiled. Now, we define some very loose cuts to
 avoid singular regions in phase space, name an infrared cutoff of 100
 MeV for all particles, a cut on the angular separation from the beam
 axis and a di-particle invariant mass cut which regularizes collinear
 singularities:
 \begin{code}
 cuts = all E >= 100 MeV [prt]
    and all abs (cos(Theta)) <= 0.99 [prt]
    and all M2 >= (1 GeV)^2 [prt, prt]
 \end{code}
 For the graphical analysis, we give a description and labels for the
 $x$- and $y$-axis in \LaTeX\ syntax:
 \begin{code}
 $description = "A WHIZARD Example"
 $x_label = "$\sqrt{s}$/GeV"
 $y_label = "$\sigma(s)$/pb"
 \end{code}
 We define two plots for the lineshape of the \eemm\ process between 88
 and 95 GeV,
 \begin{code}
 $title = "The Z Lineshape in $e^+e^-\to\mu^+\mu^-$"
 plot lineshape_born { x_min = 88 GeV  x_max = 95 GeV }
 \end{code}
 and the same for the radiative process with an additional photon:
 \begin{code}
 $title = "The Z Lineshape in $e^+e^-\to\mu^+\mu^-\gamma$"
 plot lineshape_rc { x_min = 88 GeV  x_max = 95 GeV }
 \end{code}
 %$
 The next part of the \sindarin\ file actually performs the scan:
 \begin{code}
 scan sqrts = ((88.0 GeV => 90.0 GeV /+ 0.5 GeV),
               (90.1 GeV => 91.9 GeV /+ 0.1 GeV),
               (92.0 GeV => 95.0 GeV /+ 0.5 GeV)) {
   beams = e1, E1
   integrate (bornproc) { iterations = 2:1000:"gw", 1:2000 }
   record lineshape_born (sqrts, integral (bornproc) / 1000)
   integrate (rc)   { iterations = 5:3000:"gw", 2:5000 }
   record lineshape_rc (sqrts, integral (rc) / 1000)
 }
 \end{code}
 So from 88 to 90 GeV, we go in 0.5 GeV steps, then from 90 to 92 GeV
 in tenth of GeV, and then up to 95 GeV again in half a GeV steps. The
 partonic beam definition is redundant. Then, the born process is
 integrated, using a certain specification of calls with adaptation of
 grids and weights, as well as a final pass. The lineshape of the Born
 process is defined as a \ttt{record} statement, generating tuples of
 $\sqrt{s}$ and the Born cross section (converted from femtobarn to
 picobarn). The same happens for the radiative $2\to3$ process with a
 bit more iterations because of the complexity, and the definition of
 the corresponding lineshape record.
 
 If you run the \sindarin\ script, you will find an output like:
 \begin{scriptsize}
 \begin{Verbatim}[frame=single]
            | Process library 'default_lib': loading
            | Process library 'default_lib': ... success.
            $description = "A WHIZARD Example"
            $x_label = "$\sqrt{s}$/GeV"
            $y_label = "$\sigma(s)$/pb"
            $title = "The Z Lineshape in $e^+e^-\to\mu^+\mu^-$"
            x_min =  8.800000000000E+01
            x_max =  9.500000000000E+01
            $title = "The Z Lineshape in $e^+e^-\to\mu^+\mu^-\gamma$"
            x_min =  8.800000000000E+01
            x_max =  9.500000000000E+01
            sqrts =  8.800000000000E+01
            | RNG: Initializing TAO random-number generator
            | RNG: Setting seed for random-number generator to 10713
            | Initializing integration for process bornproc:
            | ------------------------------------------------------------------------
            | Process [scattering]: 'bornproc'
            |   Library name  = 'default_lib'
            |   Process index = 1
            |   Process components:
            |     1: 'bornproc_i1':   e-, e+ => mu-, mu+ [omega]
            | ------------------------------------------------------------------------
            | Beam structure: e-, e+
            | Beam data (collision):
            |   e-  (mass = 5.1099700E-04 GeV)
            |   e+  (mass = 5.1099700E-04 GeV)
            |   sqrts = 8.800000000000E+01 GeV
            | Phase space: generating configuration ...
            | Phase space: ... success.
            | Phase space: writing configuration file 'bornproc_i1.phs'
            | Phase space: 1 channels, 2 dimensions
            | Phase space: found 1 channel, collected in 1 grove.
            | Phase space: Using 1 equivalence between channels.
            | Phase space: wood
            | Applying user-defined cuts.
            | OpenMP: Using 8 threads
            | Starting integration for process 'bornproc'
            | Integrate: iterations = 2:1000:"gw", 1:2000
            | Integrator: 1 chains, 1 channels, 2 dimensions
            | Integrator: Using VAMP channel equivalences
            | Integrator: 1000 initial calls, 20 bins, stratified = T
            | Integrator: VAMP
            |=============================================================================|
            | It      Calls  Integral[fb]  Error[fb]   Err[%]    Acc  Eff[%]   Chi2 N[It] |
            |=============================================================================|
               1        800  2.5881432E+05  1.85E+03    0.72    0.20*  48.97
               2        800  2.6368495E+05  9.25E+02    0.35    0.10*  28.32
            |-----------------------------------------------------------------------------|
               2       1600  2.6271122E+05  8.28E+02    0.32    0.13   28.32    5.54   2
            |-----------------------------------------------------------------------------|
               3       1988  2.6313791E+05  5.38E+02    0.20    0.09*  35.09
            |-----------------------------------------------------------------------------|
               3       1988  2.6313791E+05  5.38E+02    0.20    0.09   35.09
            |=============================================================================|
            | Time estimate for generating 10000 events: 0d:00h:00m:05s
            [.......]
 \end{Verbatim}
 \end{scriptsize} %$
 and then the integrations for the other energy points of the scan will
 \begin{figure}
   \centering
   \includegraphics[width=.47\textwidth]{Z-lineshape_1}
   \includegraphics[width=.47\textwidth]{Z-lineshape_2}
 \caption{\label{fig:zlineshape} $Z$ lineshape in the dimuon final
   state (left), and with an additional photon (right)}
 \end{figure}
 follow, and finally the same is done for the radiative process as
 well. At the end of the \sindarin\ script we compile the graphical
 \whizard\ analysis and direct the data for the plots into the file
 \ttt{Z-lineshape.dat}:
 \begin{code}
 compile_analysis { $out_file = "Z-lineshape.dat" }
 \end{code}
 %$
 In this case there is no event generation, but simply the cross
 section values for the scan are dumped into a data file:
 \begin{scriptsize}
 \begin{Verbatim}[frame=single]
            $out_file = "Z-lineshape.dat"
            | Opening file 'Z-lineshape.dat' for output
            | Writing analysis data to file 'Z-lineshape.dat'
            | Closing file 'Z-lineshape.dat' for output
            | Compiling analysis results display in 'Z-lineshape.tex'
 \end{Verbatim}
 \end{scriptsize}
 %$
 Fig.~\ref{fig:zlineshape} shows the graphical \whizard\ output of the
 $Z$ lineshape in the dimuon final state from the scan on the left, and
 the same for the radiative process with an additional photon on the
 right.
 
 %%%%%%%%%%%%%%%
 
 \section{$W$ pairs at LEP II}
 
 This example which can be found as file \ttt{LEP\_cc10.sin} in the
 \ttt{share/examples} directory, shows $W$ pair production in the
 semileptonic mode at LEP II with its final energy of 209 GeV. Because
 there are ten contributing Feynman diagrams, the process has been
 dubbed CC10: charged current process with 10 diagrams. We work within
 the Standard Model:
 \begin{code}
   model = SM
 \end{code}
 Then the process is defined, where no flavor summation is done for the
 jets here:
 \begin{code}
   process cc10 = e1, E1 => e2, N2, u, D
 \end{code}
 A compilation statement is optional, and then we set the muon mass to
 zero:
 \begin{code}
   mmu = 0
 \end{code}
 The final LEP center-of-momentum energy of 209 GeV is set:
 \begin{code}
   sqrts = 209 GeV
 \end{code}
 Then, we integrate the process:
 \begin{code}
   integrate (cc10) { iterations = 12:20000 }
 \end{code}
 Running the \sindarin\ file up to here, results in the output:
 \begin{scriptsize}
 \begin{Verbatim}[frame=single]
           | Process library 'default_lib': loading
           | Process library 'default_lib': ... success.
           SM.mmu =  0.000000000000E+00
           sqrts =  2.090000000000E+02
           | RNG: Initializing TAO random-number generator
           | RNG: Setting seed for random-number generator to 31255
           | Initializing integration for process cc10:
           | ------------------------------------------------------------------------
           | Process [scattering]: 'cc10'
           |   Library name  = 'default_lib'
           |   Process index = 1
           |   Process components:
           |     1: 'cc10_i1':   e-, e+ => mu-, numubar, u, dbar [omega]
           | ------------------------------------------------------------------------
           | Beam structure: [any particles]
           | Beam data (collision):
           |   e-  (mass = 5.1099700E-04 GeV)
           |   e+  (mass = 5.1099700E-04 GeV)
           |   sqrts = 2.090000000000E+02 GeV
           | Phase space: generating configuration ...
           | Phase space: ... success.
           | Phase space: writing configuration file 'cc10_i1.phs'
           | Phase space: 25 channels, 8 dimensions
           | Phase space: found 25 channels, collected in 7 groves.
           | Phase space: Using 25 equivalences between channels.
           | Phase space: wood
           Warning: No cuts have been defined.
           | OpenMP: Using 8 threads
           | Starting integration for process 'cc10'
           | Integrate: iterations = 12:20000
           | Integrator: 7 chains, 25 channels, 8 dimensions
           | Integrator: Using VAMP channel equivalences
           | Integrator: 20000 initial calls, 20 bins, stratified = T
           | Integrator: VAMP
           |=============================================================================|
           | It      Calls  Integral[fb]  Error[fb]   Err[%]    Acc  Eff[%]   Chi2 N[It] |
           |=============================================================================|
              1      19975  6.4714908E+02  2.17E+01    3.36    4.75*   2.33
              2      19975  7.3251876E+02  2.45E+01    3.34    4.72*   2.17
              3      19975  6.7746497E+02  2.39E+01    3.52    4.98    1.77
              4      19975  7.2075198E+02  2.41E+01    3.34    4.72*   1.76
              5      19975  6.5976152E+02  2.26E+01    3.43    4.84    1.46
              6      19975  6.6633310E+02  2.26E+01    3.39    4.79*   1.43
              7      19975  6.7539385E+02  2.29E+01    3.40    4.80    1.43
              8      19975  6.6754027E+02  2.11E+01    3.15    4.46*   1.41
              9      19975  7.3975817E+02  2.52E+01    3.40    4.81    1.53
             10      19975  7.2284275E+02  2.39E+01    3.31    4.68*   1.47
             11      19975  6.5476917E+02  2.18E+01    3.33    4.71    1.33
             12      19975  7.2963866E+02  2.54E+01    3.48    4.92    1.46
           |-----------------------------------------------------------------------------|
             12     239700  6.8779583E+02  6.69E+00    0.97    4.76    1.46    2.18  12
           |=============================================================================|
           | Time estimate for generating 10000 events: 0d:00h:01m:16s
           | Creating integration history display cc10-history.ps and cc10-history.pdf
 \end{Verbatim}
 \end{scriptsize}
 \begin{figure}
   \centering
   \includegraphics[width=.6\textwidth]{cc10_1}
   \\\vspace{5mm}
   \includegraphics[width=.6\textwidth]{cc10_2}
   \caption{Histogram of the dijet invariant mass from the CC10 $W$
     pair production at LEP II, peaking around the $W$ mass (upper
     plot), and of the muon energy (lower plot).}
   \label{fig:cc10}
 \end{figure}
 The next step is event generation. In order to get smooth
 distributions, we set the integrated luminosity to 10
 fb${}^{-1}$. (Note that LEP II in its final year 2000 had an
 integrated luminosity of roughly 0.2 fb${}^{-1}$.)
 \begin{code}
   luminosity = 10
 \end{code}
 With the simulated events corresponding to those 10 inverse femtobarn
 we want to perform a \whizard\ analysis: we are going to plot the
 dijet invariant mass, as well as the energy of the outgoing muon. For
 the plot of the analysis, we define a description and label the $y$
 axis:
 \begin{code}
 $description =
   "A WHIZARD Example.
    Charged current CC10 process from LEP 2."
 $y_label = "$N_{\textrm{events}}$"
 \end{code}
 We also use \LaTeX-syntax for the title of the first plot and the
 $x$-label, and then define the histogram of the dijet invariant mass
 in the range around the $W$ mass from 70 to 90 GeV in steps of half a
 GeV:
 \begin{code}
 $title = "Di-jet invariant mass $M_{jj}$ in $e^+e^- \to \mu^- \bar\nu_\mu u \bar d$"
 $x_label = "$M_{jj}$/GeV"
 histogram m_jets (70 GeV, 90 GeV, 0.5 GeV)
 \end{code}
 And we do the same for the second histogram of the muon energy:
 \begin{code}
 $title = "Muon energy $E_\mu$ in $e^+e^- \to \mu^- \bar\nu_\mu u \bar d$"
 $x_label = "$E_\mu$/GeV"
 histogram e_muon (0 GeV, 209 GeV, 4)
 \end{code}
 Now, we define the \ttt{analysis} consisting of two \ttt{record}
 statements initializing the two observables that are plotted as
 histograms:
 \begin{code}
 analysis = record m_jets (eval M [u,D]);
            record e_muon (eval E [e2])
 \end{code}
 At the very end, we perform the event generation
 \begin{code}
 simulate (cc10)
 \end{code}
 and finally the writing and compilation of the analysis in a named
 data file:
 \begin{code}
 compile_analysis { $out_file = "cc10.dat" }
 \end{code}
 This event generation part screen output looks like this:
 \begin{scriptsize}
 \begin{Verbatim}[frame=single]
           luminosity =  1.000000000000E+01
           $description = "A WHIZARD Example.
              Charged current CC10 process from LEP 2."
           $y_label = "$N_{\textrm{events}}$"
           $title = "Di-jet invariant mass $M_{jj}$ in $e^+e^- \to \mu^- \bar\nu_\mu u \bar d$"
           $x_label = "$M_{jj}$/GeV"
           $title = "Muon energy $E_\mu$ in $e^+e^- \to \mu^- \bar\nu_\mu u \bar d$"
           $x_label = "$E_\mu$/GeV"
           | Starting simulation for process 'cc10'
           | Simulate: using integration grids from file 'cc10_m1.vg'
           | RNG: Initializing TAO random-number generator
           | RNG: Setting seed for random-number generator to 9910
           | OpenMP: Using 8 threads
           | Simulation: using n_events as computed from luminosity value
           | Events: writing to raw file 'cc10.evx'
           | Events: generating 6830 unweighted, unpolarized events ...
           | Events: event normalization mode '1'
           |         ... event sample complete.
           Warning: Encountered events with excess weight: 39 events (  0.571 %)
           | Maximum excess weight = 1.027E+00
           | Average excess weight = 6.764E-04
           | Events: closing raw file 'cc10.evx'
           $out_file = "cc10.dat"
           | Opening file 'cc10.dat' for output
           | Writing analysis data to file 'cc10.dat'
           | Closing file 'cc10.dat' for output
           | Compiling analysis results display in 'cc10.tex'
 \end{Verbatim}
 \end{scriptsize} %$
 Then comes the \LaTeX\ output of the compilation of the graphical
 analysis. Fig.~\ref{fig:cc10} shows the two histograms as the are
 produced as result of the \whizard\ internal graphical analysis.
 
 %%%%%%%%%%%%%%%
 
 \section{Higgs search at LEP II}
 
 This example can be found under the name \ttt{LEP\_higgs.sin} in the
 \ttt{share/doc} folder of \whizard. It displays different search
 channels for a very light would-be SM Higgs boson of mass 115 GeV at
 the LEP II machine at its highest energy it finally achieved, 209 GeV.
 First, we use the Standard Model:
 \begin{code}
 model = SM
 \end{code}
 Then, we define aliases for neutrinos, antineutrinos, light quarks and
 light anti-quarks:
 \begin{code}
 alias n = n1:n2:n3
 alias N = N1:N2:N3
 alias q = u:d:s:c
 alias Q = U:D:S:C
 \end{code}
 Now, we define the signal process, which is Higgsstrahlung,
 \begin{code}
 process zh = e1, E1 => Z, h
 \end{code}
 the missing-energy channel,
 \begin{code}
 process nnbb = e1, E1 => n, N, b, B
 \end{code}
 and finally the 4-jet as well as dilepton-dijet channels:
 \begin{code}
 process qqbb = e1, E1 => q, Q, b, B
 process bbbb = e1, E1 => b, B, b, B
 process eebb = e1, E1 => e1, E1, b, B
 process qqtt = e1, E1 => q, Q, e3, E3
 process bbtt = e1, E1 => b, B, e3, E3
 
 compile
 \end{code}
 and we compile the code. We set the center-of-momentum energy to the
 highest energy LEP II achieved,
 \begin{code}
 sqrts = 209 GeV
 \end{code}
 For the Higgs boson, we take the values of a would-be SM Higgs boson
 with mass of 115 GeV, which would have had a width of a bit more than
 3 MeV:
 \begin{code}
 mH = 115 GeV
 wH = 3.228 MeV
 \end{code}
 We take a running $b$ quark mass to take into account NLO corrections
 to the $Hb\bar b$ vertex, while all other fermions are massless:
 \begin{code}
 mb = 2.9 GeV
 me = 0
 ms = 0
 mc = 0
 \end{code}
 \begin{scriptsize}
 \begin{Verbatim}[frame=single]
            | Process library 'default_lib': loading
            | Process library 'default_lib': ... success.
            sqrts =  2.090000000000E+02
            SM.mH =  1.150000000000E+02
            SM.wH =  3.228000000000E-03
            SM.mb =  2.900000000000E+00
            SM.me =  0.000000000000E+00
            SM.ms =  0.000000000000E+00
            SM.mc =  0.000000000000E+00
 \end{Verbatim}
 \end{scriptsize}
 To avoid soft-collinear singular phase-space regions, we apply an
 invariant mass cut on light quark pairs:
 \begin{code}
 cuts = all M >= 10 GeV [q,Q]
 \end{code}
 Now, we integrate the signal process as well as the combined signal
 and background processes:
 \begin{code}
 integrate (zh) { iterations = 5:5000}
 
 integrate(nnbb,qqbb,bbbb,eebb,qqtt,bbtt) { iterations = 12:20000 }
 \end{code}
 \begin{scriptsize}
 \begin{Verbatim}[frame=single]
            | RNG: Initializing TAO random-number generator
            | RNG: Setting seed for random-number generator to 21791
            | Initializing integration for process zh:
            | ------------------------------------------------------------------------
            | Process [scattering]: 'zh'
            |   Library name  = 'default_lib'
            |   Process index = 1
            |   Process components:
            |     1: 'zh_i1':   e-, e+ => Z, H [omega]
            | ------------------------------------------------------------------------
            | Beam structure: [any particles]
            | Beam data (collision):
            |   e-  (mass = 0.0000000E+00 GeV)
            |   e+  (mass = 0.0000000E+00 GeV)
            |   sqrts = 2.090000000000E+02 GeV
            | Phase space: generating configuration ...
            | Phase space: ... success.
            | Phase space: writing configuration file 'zh_i1.phs'
            | Phase space: 1 channels, 2 dimensions
            | Phase space: found 1 channel, collected in 1 grove.
            | Phase space: Using 1 equivalence between channels.
            | Phase space: wood
            | Applying user-defined cuts.
            | OpenMP: Using 8 threads
            | Starting integration for process 'zh'
            | Integrate: iterations = 5:5000
            | Integrator: 1 chains, 1 channels, 2 dimensions
            | Integrator: Using VAMP channel equivalences
            | Integrator: 5000 initial calls, 20 bins, stratified = T
            | Integrator: VAMP
            |=============================================================================|
            | It      Calls  Integral[fb]  Error[fb]   Err[%]    Acc  Eff[%]   Chi2 N[It] |
            |=============================================================================|
               1       4608  1.6114109E+02  5.52E-04    0.00    0.00*  99.43
               2       4608  1.6114220E+02  5.59E-04    0.00    0.00   99.43
               3       4608  1.6114103E+02  5.77E-04    0.00    0.00   99.43
               4       4608  1.6114111E+02  5.74E-04    0.00    0.00*  99.43
               5       4608  1.6114103E+02  5.66E-04    0.00    0.00*  99.43
            |-----------------------------------------------------------------------------|
               5      23040  1.6114130E+02  2.53E-04    0.00    0.00   99.43    0.82   5
            |=============================================================================|
            [.....]
 \end{Verbatim}
 \end{scriptsize}
 \begin{figure}
   \centering
   \includegraphics[width=.48\textwidth]{lep_higgs_1}
   \includegraphics[width=.48\textwidth]{lep_higgs_2}
   \\\vspace{5mm}
   \includegraphics[width=.48\textwidth]{lep_higgs_3}
   \caption{Upper line: final state $bb + E_{miss}$, histogram of
     the invisible mass distribution (left), and of the di-$b$
     distribution (right). Lower plot: light dijet distribution in the
     $bbjj$ final state.}
   \label{fig:lep_higgs}
 \end{figure}
 Because the other integrations look rather similar, we refrain from
 displaying them here, too. As a next step, we define titles,
 descriptions and axis labels for the histograms we want to
 generate. There are two of them, one os the invisible mass
 distribution, the other is the di-$b$-jet invariant mass. Both
 histograms are taking values between 70 and 130 GeV with
 bin widths of half a GeV:
 \begin{code}
 $description =
   "A WHIZARD Example. Light Higgs search at LEP. A 115 GeV pseudo-Higgs
     has been added. Luminosity enlarged by two orders of magnitude."
 $y_label = "$N_{\textrm{events}}$"
 
 $title = "Invisible mass distribution in $e^+e^- \to \nu\bar\nu b \bar b$"
 $x_label = "$M_{\nu\nu}$/GeV"
 histogram m_invisible (70 GeV, 130 GeV, 0.5 GeV)
 
 $title = "$bb$ invariant mass distribution in $e^+e^- \to \nu\bar\nu b \bar b$"
 $x_label = "$M_{b\bar b}$/GeV"
 histogram m_bb (70 GeV, 130 GeV, 0.5 GeV)
 \end{code}
 The analysis is initialized by defining the two records for the
 invisible mass and the invariant mass of the two $b$ jets:
 \begin{code}
 analysis = record m_invisible (eval M [n,N]);
            record m_bb (eval M [b,B])
 \end{code}
 In order to have enough statistics, we enlarge the LEP integrated
 luminosity at 209 GeV by more than two orders of magnitude:
 \begin{code}
 luminosity = 10
 \end{code}
 We start event generation by simulating the process with two $b$ jets
 and two neutrinos in the final state:
 \begin{code}
 simulate (nnbb)
 \end{code}
 As a third histogram, we define the dijet invariant mass of two light
 jets:
 \begin{code}
 $title = "Dijet invariant mass distribution in $e^+e^- \to q \bar q b \bar b$"
 $x_label = "$M_{q\bar q}$/GeV"
 histogram m_jj (70 GeV, 130 GeV, 0.5 GeV)
 \end{code}
 Then we simulate the 4-jet process defining the light-dijet
 distribution as a local record:
 \begin{code}
 simulate (qqbb) { analysis = record m_jj (eval M / 1 GeV [combine [q,Q]]) }
 \end{code}
 Finally, we compile the analysis,
 \begin{code}
 compile_analysis { $out_file = "lep_higgs.dat" }
 \end{code}
 \begin{scriptsize}
 \begin{Verbatim}[frame=single]
            | Starting simulation for process 'nnbb'
            | Simulate: using integration grids from file 'nnbb_m1.vg'
            | RNG: Initializing TAO random-number generator
            | RNG: Setting seed for random-number generator to 21798
            | OpenMP: Using 8 threads
            | Simulation: using n_events as computed from luminosity value
            | Events: writing to raw file 'nnbb.evx'
            | Events: generating 1070 unweighted, unpolarized events ...
            | Events: event normalization mode '1'
            |         ... event sample complete.
            Warning: Encountered events with excess weight: 207 events ( 19.346 %)
            | Maximum excess weight = 1.534E+00
            | Average excess weight = 4.909E-02
            | Events: closing raw file 'nnbb.evx'
            $title = "Dijet invariant mass distribution in $e^+e^- \to q \bar q b \bar b$"
            $x_label = "$M_{q\bar q}$/GeV"
            | Starting simulation for process 'qqbb'
            | Simulate: using integration grids from file 'qqbb_m1.vg'
            | RNG: Initializing TAO random-number generator
            | RNG: Setting seed for random-number generator to 21799
            | OpenMP: Using 8 threads
            | Simulation: using n_events as computed from luminosity value
            | Events: writing to raw file 'qqbb.evx'
            | Events: generating 4607 unweighted, unpolarized events ...
            | Events: event normalization mode '1'
            |         ... event sample complete.
            Warning: Encountered events with excess weight: 112 events (  2.431 %)
            | Maximum excess weight = 8.875E-01
            | Average excess weight = 4.030E-03
            | Events: closing raw file 'qqbb.evx'
            $out_file = "lep_higgs.dat"
            | Opening file 'lep_higgs.dat' for output
            | Writing analysis data to file 'lep_higgs.dat'
            | Closing file 'lep_higgs.dat' for output
            | Compiling analysis results display in 'lep_higgs.tex'
 \end{Verbatim}
 \end{scriptsize}
 The graphical analysis of the events generated by \whizard\ are shown
 in Fig.~\ref{fig:lep_higgs}. In the upper left, the invisible mass
 distribution in the $b\bar b + E_{miss}$ state is shown, peaking
 around the $Z$ mass. The upper right shows the $M(b\bar b)$
 distribution in the same final state, while the lower plot has the
 invariant mass distribution of the two non-$b$-tagged (light) jets in
 the $bbjj$ final state. The latter shows only the $Z$
 peak, while the former exhibits the narrow would-be 115 GeV Higgs
 state.
 
 %%%%%%%%%%%%%%%
 
 \section{Deep Inelastic Scattering at HERA}
 
 %%%%%%%%%%%%%%%
 
 \section{$W$ endpoint at LHC}
 
 %%%%%%%%%%%%%%%
 
 \section{SUSY Cascades at LHC}
 
 %%%%%%%%%%%%%%%
 
 \section{Polarized $WW$ at ILC}
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \chapter{Technical details -- Advanced Spells}
 \label{chap:tuning}
 
 \section{Efficiency and tuning}
 
 Since massless fermions and vector bosons (or almost massless states
 in a certain approximation) lead to restrictive selection rules for
 allowed helicity combinations in the initial and final state. To make
 use of this fact for the efficiency of the \whizard\ program, we are
 applying some sort of heuristics: \whizard\ dices events into all
 combinatorially possible helicity configuration during a warm-up
 phase. The user can specify a helicity threshold which sets the number
 of zeros \whizard\ should have got back from a specific helicity
 combination in order to ignore that combination from now on. By that
 mechanism, typically half up to more than three quarters of all
 helicity combinations are discarded (and hence the corresponding
 number of matrix element calls). This reduces calculation time up to
 more than one order of magnitude. \whizard\ shows at the end of the
 integration those helicity combinations which finally contributed to
 the process matrix element.
 
 Note that this list -- due to the numerical heuristics -- might very
 well depend on the number of calls for the matrix elements per
 iteration, and also on the corresponding random number seed.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \chapter{New External Physics Models}
 \label{chap:extmodels}
 
 It is never possible to include all incarnations of physics models that
 can be described by the maybe weirdest form of a quantum field theory
 in a tailor-made implementation within a program like \whizard. Users
 clearly want to be able to use their own special type of model; in
 order to do so there are external tools to translate models described
 by their field content and Lagrangian densities into Feynman rules and
 make them available in an event generator like \whizard. In this
 chapter, we describe the interfaces to two such external models,
 \sarah\ and \FeynRules.
 
 The \FeynRules\ interface had been started already for the legacy
 version \whizard\ttt{1} (where it had to be downloaded from
 \url{https://projects.hepforge.org/whizard} as a separate package), but
 for the \whizard\ttt{two} release series it has been included in the
 \FeynRules\ package (from their version v1.6.0 on). Note that there
 was a regression for the usage of external models (from either \sarah\
 or \FeynRules) in the first release of series v2.2, v2.2.0. This has
 been fixed in all upcoming versions.
 
 Besides using \sarah\ or \FeynRules\ via their interfaces, there is
 now a much easier way to let those programs output model files in the
 "Universal FeynRules Output" (or \UFO). This option does not have any
 principle limitations for models, and also does not rely on the never
 truly constant interfaces between two different tools. Their usage is
 described in Sec.~\ref{sec:ufo}.
 
 %%%%%%%%%%%%%%%
 
 \section{New physics models via \sarah}
 \sarah~\cite{Staub:2008uz,Staub:2009bi,Staub:2010jh,Staub:2012pb,Staub:2013tta}
 is a \Mathematica~\cite{mathematica} package which
 derives for a given model the
 minimum conditions of the vacuum, the mass matrices, and vertices at tree-level
 as well as expressions for the one-loop corrections for all masses and the
 full two-loop renormalization group equations (RGEs). The vertices can be exported
 to be used with \whizard/\oMega. All other information can be used to generate
 \fortran\ source code for the RGE solution tool and spectrum generator
 \spheno~\cite{Porod:2003um,Porod:2011nf}  to get a spectrum generator
 for any model. The
 advantage is that \spheno\ calculates a consistent set of parameters (couplings,
 masses, rotation matrices, decay widths) which can be used as input for \whizard.
 \sarah\ and \spheno\ can be also downloaded from the \ttt{HepForge} server:
 \begin{center}
 \url{https://sarah.hepforge.org} \\
 \url{https://spheno.hepforge.org}
 \end{center}
 
 
 \subsection{\whizard/\oMega\ model files from \sarah}
 
 \subsubsection{Generating the model files}
 
 Here we are giving only the information relevant to generate models
 for \whizard. For more details about the installation of \sarah\ and
 an exhaustion documentation about its usage, confer the \sarah\
 manual.
 
 To generate the model files for \whizard/\oMega\ with \sarah, a
 new \Mathematica\ session has to be started. \sarah\ is loaded via
 \begin{code}
 <<SARAH-4.2.1/SARAH.m;
 \end{code}
 if \sarah\ has been stored in the applications directory of
 \Mathematica. Otherwise, the full path has to be given
 \begin{code}
 <<[Path_to_SARAH]/SARAH.m;
 \end{code}
 To get an overview which models are delivered with \sarah, the command \verb"ShowModels"
 can be used. As an example, we use in the following the triplet
 extended MSSM (TMSSM) and initialize it in \sarah\ via
 \begin{code}
 Start["TMSSM"];
 \end{code}
 Finally, the output intended for \whizard/\oMega\ is started via
 \begin{code}
 MakeWHIZARD[Options]
 \end{code}
 The possible options of the \verb"MakeWHIZARD" command are
 \begin{enumerate}
   \item \verb"WriteOmega", with values: \verb"True" or \verb"False", default:
     \verb"True" \\
     Defines if the model files for \oMega\ should be written
   \item \verb"WriteWHIZARD", with values: \verb"True" or \verb"False",
     default: \verb"True" \\
     Defines if the model files for \whizard\ should be written
   \item \verb"Exclude", with values: list of generic type, Default:
     \verb"{SSSS}" \\
     Defines which generic vertices are {\em not} exported to the model
     file
   \item \verb"WOModelName", with values: string, default: name of the
     model in \sarah\ followed by \verb"_sarah"  \\
     Gives the possibility to change the model name
   \item \verb"MaximalCouplingsPerFile", with values: integer, default:
     \ttt{150} \\
     Defines the maximal number of couplings written per file
   \item \verb"Version", with values: formatted number, Default:
     \verb"2.2.1"~\footnote{Due to a regression in \whizard\ version
       v2.2.0, \sarah\ models cannot be successfully linked within
       that version. Hence, the default value here has been set to
       version number 2.2.1}, \\
     Defines the version of \whizard\ for which the model file is generated
 \end{enumerate}
 All options and the default values are also shown in the
 \Mathematica\ session via \newline\verb"Options[MakeWHIZARD]".
 
 \subsubsection{Using the generated model files with \whizard}
 
 After the interface has completed evaluation, the generated files can
 be found in the subdirectory \verb"WHIZARD_Omega" of {\sarah}s output
 directory. In order to use it the generated code must be compiled and
 installed. For this purpose, open a terminal, enter the output directory
 \begin{code}
 <PATH_to_SARAH>/Output/TMSSM/EWSB/WHIZARD_Omega/
 \end{code}
 and run
 %
 \begin{code}
 ./configure
 make install
 \end{code}
 %
 By default, the last command installs the compiled model into \verb".whizard"
 in current user's home directory where it is automatically picked up by
 \whizard. Alternative installation paths can be specified using the
 \verb"--prefix" option to \whizard.
 %
 \begin{code}
 ./configure --prefix=/path/to/installation/prefix
 \end{code}
 %
 If the files are installed into the \whizard\
 installation prefix, the program will also pick them up automatically, while
 {\whizard}'s \verb"--localprefix" option must be used to communicate any other
 choice to \whizard. In case \whizard\ is not available in the binary search
 path, the \verb"WO_CONFIG" environment variable can be used to point
 \verb"configure" to the binaries
 %
 \begin{code}
 ./configure WO_CONFIG=/path/to/whizard/binaries
 \end{code}
 %
 More information on the available options and their syntax can be obtained with
 the
 \verb"--help" option.
 
 After the model is compiled it can be used in \whizard\ as
 \begin{code}
 model = tmssm_sarah
 \end{code}
 
 
 
 \subsection{Linking \spheno\ and \whizard}
 As mentioned above, the user can also use \spheno\ to generate spectra
 for its models. This is done by means of \fortran\ code for \spheno,
 exported from \sarah.  To do so, the user has to apply the command
 \verb"MakeSPheno[]". For more details
 about the options of this command and how to compile and use the \spheno\ output,
 we refer to the \sarah\ manual. \\
 As soon as the \spheno\ version for the given model is ready it can be used to
 generate files with all necessary numerical values for the parameters in a format
 which is understood by \whizard. For this purpose, the corresponding flag in the
 Les Houches input file of \spheno\ has to be turned on:
 \begin{code}
 Block SPhenoInput   # SPheno specific input
 ...
 75 1               # Write WHIZARD files
 \end{code}
 Afterwards, \spheno\ returns not only the spectrum file in the
 standard SUSY Les Houches accord (SLHA) format (for more details about
 the SLHA and the \whizard\ SLHA interface cf. Sec.~\ref{sec:slha}),
 but also an additional file called \verb"WHIZARD.par.TMSSM" for our example.
 This file can be used
 in the \sindarin\ input file via
 \begin{code}
 include ("WHIZARD.par.TMSSM")
 \end{code}
 
 %%%%%
 
 \subsection{BSM Toolbox}
 
 A convenient way to install \sarah\ together with \whizard, \spheno\
 and some  other codes are the \ttt{BSM Toolbox} scripts
 \footnote{Those script have been published
 under the name SUSY Toolbox but \sarah\ is with version 4 no longer
 restricted to SUSY models}~\cite{Staub:2011dp}. These scripts are
 available at
 \begin{center}
  \url{https://projects.hepforge.org/sarah/Toolbox.html}
 \end{center}
 The \ttt{Toolbox} provides two scripts. First, the \verb"configure" script is
 used via
 \begin{code}
 toolbox-src-dir> mkdir build
 toolbox-src-dir> cd build
 toolbox-src-dir> ../configure
 \end{code}
 %
 The  \verb"configure" script checks for the requirements of the
 different packages and downloads all codes. All downloaded archives will
 be placed in the \verb"tarballs" subdirectory of the directory containing the
 \verb"configure" script.
 Command line options can be used to disable specific packages and to point the
 script to custom locations of compilers and of the \Mathematica\ kernel; a full
 list of those can be obtained by calling \verb"configure" with the \verb"--help"
 option.
 
 After \verb"configure" finishes successfully, \verb"make" can be called to build
 all configured packages
 %
 \begin{code}
 toolbox-build-dir> make
 \end{code}
 
 \verb"configure" creates also the second script which automates the implementation
 of a new model into all packages. The \verb"butler" script takes as argument the
 name of the model in \sarah, e.g.
 \begin{code}
 > ./butler TMSSM
 \end{code}
 The \verb"butler" script runs \sarah\ to get the output in the same
 form as the \whizard/\oMega\
 model files and the code for \spheno. Afterwards, it installs the
 model in all packages and compiles the new \whizard/\oMega\ model
 files as well as the new \spheno\ module.
 
 %%%%%
 \newpage
 
 \section{New physics models via \FeynRules}
 
 In this section, we present the interface between the external tool
 \FeynRules\ \cite{Christensen:2008py,Christensen:2009jx,Duhr:2011se}
 and \whizard. \FeynRules\ is a
 \Mathematica~\cite{mathematica} package that allows to derive
 Feynman rules from any perturbative quantum field theory-based Lagrangian
 in an automated way. It can be downloaded from
 \begin{center}
   \url{http://feynrules.irmp.ucl.ac.be/}
 \end{center}
 The input provided by the user is threefold and consists
 of the Lagrangian defining the model, together with the definitions of
 all the
 particles and parameters that appear in the model.
 Once this information is provided, \FeynRules\ can perform basic checks
 on the sanity of the implementation (e.g. hermiticity, normalization
 of the quadratic terms), and finally computes all the interaction
 vertices associated  with the model and store them in an internal
 format for later processing. After the Feynman rules have been
 obtained, \FeynRules\ can export the interaction vertices to \whizard\
 via a dedicated interface~\cite{Christensen:2010wz}. The interface
 checks whether all the vertices are compliant with the structures
 supported by \whizard's
 matrix element generator \oMega, and discard them in the case
 they are not supported. The output of the interface consists of a set
 of files organized in a single directory which can be injected into
 \whizard/\oMega\ and used as any other built-in models. Together with
 the model files, a framework is created which allows to communicate
 the new models to \whizard\ in a well defined way, after which
 step the model can be used exactly like the built-in ones.
 This specifically means that the user is not required to
 manually modify the code of \whizard/\oMega, the models created by the
 interface can be used directly without any further user intervention.
 We first describe the installation and general usage of the interface,
 and then list the general properties like the supported particle
 types, color quantum numbers and Lorentz structures as well as types
 of gauge interactions.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \subsection{Installation and Usage of the \whizard-\FeynRules\ interface}
 \label{sec:interface-usage}
 
 \paragraph{{\bf Installation and basic usage:}}
 %
 From \FeynRules\ version 1.6.0 onward, the interface to \whizard\ is
 part of the \FeynRules\ distribution\footnote{Note that though the
   main interface of \FeynRules\ to \whizard\ is for the most recent
   \whizard\ release, but also the legacy branch
   \whizard\ttt{1} is supported.}. In addition, the latest version
 of the interface can be downloaded from the \whizard\ homepage on
 \ttt{HepForge}. There you can also find an installer that can be used
 to inject the interface into an existing \FeynRules\
 installation (which allows to use the interface with the \FeynRules\
 release series1.4.x where it is not part of the package).
 
 Once installed, the interface can be called and used in the same way
 \FeynRules' other interfaces described
 in~\cite{Christensen:2008py}. The details of how to install and use
 \FeynRules\ itself can be found
 there,~\cite{Christensen:2008py,Christensen:2009jx,Duhr:2011se}. Here,
 we only describe how to use the interface to inject new models into
 \whizard.  For example, once the  \FeynRules\ environment has been
 initialized and a model has been loaded, the command
 \begin{code}
   WriteWOOutput[L]
 \end{code}
 will call the \ttt{FeynmanRules} command to extract the Feynman
 rules from the Lagrangian \ttt{L}, translate them together with the
 model data and finally write the files necessary for using the model
 within \whizard\ to an output directory (the name of which is inferred
 from the model name by default). Options can be added for further
 control over the translation process (see
 Sec.~\ref{app:interface-options}). Instead of using a Lagrangian, it
 is also possible to call the interface on a pure vertex list. For
 example, the following command
 \begin{code}
   WriteWOOutput[Input -> list]
 \end{code}
 will directly translate the vertex list \ttt{list}. Note that this
 vertex list must be given in flavor-expanded form in order for the
 interface to process it correctly.
 
 The interface also supports the \ttt{WriteWOExtParams} command
 described in~\cite{Christensen:2008py}. Issuing
 \begin{code}
   WriteWOExtParams[filename]
 \end{code}
 will write a list of all the external parameters to
 \ttt{filename}. This is done in the form of a \sindarin\
 script. The only option accepted by the command above is the target
 version of \whizard, set by the option \ttt{WOWhizardVersion}.
 
 During execution, the interface will print out a series of
 messages. It is highly advised to carefully read through this output
 as it not only summarizes the settings and the location of the output
 files, but also contains information on any skipped vertices or
 potential incompatibilities of the model with \whizard.
 
 After the interface has run successfully and written the model files to the
 output directory, the model must be imported into \whizard. For doing
 so, the model files have to be compiled and can then be installed
 independently of \whizard. In the simplest scenario, assuming that the
 output directory is the current working directory and that the
 \whizard\ binaries can be found in the current \ttt{\$\{PATH\}},
 the installation is performed by simply executing
 \begin{code}
 ./configure~\&\&~make clean~\&\&~make install
 \end{code}
 
 This will compile the model and install it into the directory
 \ttt{\$\{HOME\}/.whizard}, making it fully available to \whizard\
 without any further intervention. The build system can be adapted to
 more complicated cases through several options to the
 \ttt{configure} which are listed in the \ttt{INSTALL} file
 created in the output directory. A detailed explanation of all options
 can be found in Sec.~\ref{app:interface-options}.
 
 \paragraph{\bf Supported fields and vertices:}
 
 The following fields are currently supported by the interface:
 scalars, Dirac and Majorana fermions, vectors and symmetric tensors.
 The set of accepted operators, the full list of which can be found in
 Tab.~\ref{tab-operators}, is a subset of all the operators supported
 by \oMega. While still limited, this list is sufficient for a large
 number of BSM models. In addition, a future version of
 \whizard/\oMega\ will support the definition of completely general
 Lorentz structures in the model, allowing the interface to
 translate all interactions handled by \FeynRules. This will be done by
 means of a parser within \oMega\ of the \ttt{UFO} file format for
 model files from \FeynRules.
 
 \begin{table*}[!t]
 \centerline{\begin{tabular}{|c|c|}
 \hline Particle spins & Supported Lorentz structures \\\hline\hline
 FFS & \parbox{0.7\textwidth}{\raggedright
    All operators of dimension four are supported.
 \strut}\\\hline
 FFV & \parbox[t]{0.7\textwidth}{\raggedright
    All operators of dimension four are
    supported.
 \strut}\\\hline
 SSS & \parbox{0.7\textwidth}{\raggedright
    All dimension three interactions are supported.
 \strut}\\\hline
 SVV & \parbox[t]{0.7\textwidth}{\raggedright
    Supported operators:\\
    \mbox{}\hspace{5ex}$\begin{aligned}
       \text{dimension 3:} & \quad\mathcal{O}_3 = V_1^\mu V_{2\mu}\phi \mbox{}\\
       \text{dimension 5:} & \quad\mathcal{O}_5 = \phi
          \left(\partial^\mu V_1^\nu - \partial^\nu V_1^\mu\right)
          \left(\partial_\mu V_{2\nu} - \partial_\nu V_{2\mu}\right)
    \end{aligned}$\\
 Note that $\mathcal{O}_5$ generates the effective gluon-gluon-Higgs couplings obtained by integrating out heavy quarks.
 \strut}\\\hline
 SSV & \parbox[t]{0.7\textwidth}{\raggedright
    $\left(\phi_1\partial^\mu\phi_2 - \phi_2\partial^\mu\phi_1\right)V_\mu\;$
    type interactions are supported.
 \strut}\\\hline
 SSVV & \parbox{0.7\textwidth}{\raggedright
    All dimension four interactions are supported.
 \strut}\\\hline
 SSSS & \parbox{0.7\textwidth}{\raggedright
    All dimension four interactions are supported.
 \strut}\\\hline
 VVV & \parbox[t]{0.7\textwidth}{\raggedright
    All parity-conserving dimension four operators are supported, with
    the restriction that non-gauge interactions may be split into
    several vertices and can only be handled if all three fields are
    mutually different.\strut
 \strut}\\\hline
 VVVV & \parbox[t]{0.7\textwidth}{\raggedright
    All parity conserving dimension four operators are supported.
 \strut}\\\hline
 TSS, TVV, TFF & \parbox[t]{0.7\textwidth}{\raggedright
    The three point couplings in the Appendix of Ref.\
    \cite{Han:1998sg} are supported.
 \strut}\\\hline
 \end{tabular}}
 \caption{All Lorentz structures currently supported by the
   \whizard-\FeynRules\ interface, sorted with respect to the spins of
   the particles. ``S'' stands for scalar, ``F'' for fermion (either
   Majorana or Dirac) and ``V'' for vector.}
 \label{tab-operators}
 \end{table*}
 
 \paragraph{\bf Color:}
 %
 Color is treated in \oMega\ in the color flow decomposition,
 with the flow structure being implicitly determined from
 the representations of the particles present at the vertex. Therefore, the
 interface has to strip the color structure from the vertices derived by
 \FeynRules\ before writing them out to the model files.
 While this process is straightforward for all color structures which
 correspond only to a single flow assignment, vertices with several
 possible flow configurations must be treated with care in order to
 avoid mismatches between the flows assigned by \oMega\ and those
 actually encoded in the couplings. To this end, the interface derives
 the color flow decomposition from the color structure determined by
 \FeynRules\ and rejects all vertices which would lead to a wrong flow
 assignment by \oMega\ (these rejections are accompanied by warnings
 from the interface)\footnote{For the old \whizard\ttt{1} legacy
   branch, there was a maximum number of external color flows that had
   to explicitly specified. Essentially, this is $n_8 - \frac{1}{2}n_3$
   where $n_8$ is the maximum number of external color octets and $n_3$
   is the maximum number of external triplets and antitriplets. This
   can be set in the \whizard/\FeynRules\ interface by the
   \ttt{WOMaxNcf} command, whose default is \ttt{4}.}.
 
 At the moment, the $SU(3)_C$ representations supported by
 both \whizard\ and the interface are singlets ($1$), triplets ($3$),
 antitriplets ($\bar{3}$) and octets ($8$). Tab.~\ref{tab:su3struct}
 shows all combinations of these representations which can
 form singlets together with the support status of the respective color
 structures in \whizard\ and the interface. Although the supported
 color structures do not comprise all possible singlets, the list is
 sufficient for a large number of SM extensions. Furthermore, a future
 revision of \whizard/\oMega\ will allow for explicit color flow
 assignments, thus removing most of the current restrictions.
 
 \begin{table*}
 \centerline{\begin{tabular}{|c|c|}
 \hline $SU(3)_C$ representations &
    Support status
 \\\hline\hline
 \parbox[t]{0.2\textwidth}{
    \centerline{\begin{tabular}[t]{lll}
    $111,\quad$ & $\bar{3}31,\quad$ & $\bar{3}38,$ \\
    $1111,$ & $\bar{3}311,$ & $\bar{3}381$
    \end{tabular}}} &
 \parbox[t]{0.7\textwidth}{\raggedright\strut Fully supported by the interface\strut}
 \\\hline
 $888,\quad 8881$ &
 \parbox{0.7\textwidth}{\raggedright\strut Supported only if at least two of the octets
 are identical particles.\strut}
 \\\hline
 $881,\quad 8811$ &
 \parbox{0.7\textwidth}{\raggedright\strut Fully supported by the
   interface\footnote{%
     Not available in version 1.95 and earlier. Note that in order to
     use such couplings in 1.96/97, the
     \oMega\ option \ttt{2g} must be added to the process definition
     in \ttt{whizard.prc}.}.\strut}
 \\\hline
 $\bar{3}388$ &
 \parbox{0.7\textwidth}{\raggedright\strut Supported only if the octets
   are identical
 particles.\strut}
 \\\hline
 $8888$ &
 \parbox{0.7\textwidth}{\raggedright\strut The only supported flow structure is
 \begin{equation*}
 \parbox{21mm}{\includegraphics{flow4}}\cdot\;\Gamma(1,2,3,4)
    \quad+\quad \text{all acyclic permutations}
 \end{equation*}
 where $\Gamma(1,2,3,4)$ represents the Lorentz structure associated with the
 first flow.\strut}
 \\\hline
 \parbox[t]{0.2\textwidth}{
    \centerline{\begin{tabular}[t]{lll}
    $333,\quad$ & $\bar{3}\bar{3}\bar{3},\quad$ & $3331$\\
    $\bar{3}\bar{3}\bar{3}1,$ & $\bar{3}\bar{3}33$
    \end{tabular}}} &
 \parbox[t]{0.7\textwidth}{\raggedright\strut Unsupported (at the
   moment)\strut}
 \\\hline
 \end{tabular}}
 \caption{All possible combinations of three or four $SU(3)_C$
 representations supported by \FeynRules\ which can be used to build singlets,
 together with the support status of the corresponding color structures in
 \whizard\ and the interface.}
 \label{tab:su3struct}
 \end{table*}
 
 \paragraph{\bf Running $\alpha_S$:}
 
 While a running strong coupling is fully supported by the interface, a
 choice has to be made which quantities are to be reevaluated when the
 strong coupling is evolved. By default \ttt{aS}, \ttt{G} (see
 Ref.~\cite{Christensen:2008py} for the nomenclature regarding
 the QCD coupling) and any vertex factors depending on them are evolved.
 The list of internal parameters that are to be recalculated (together
 with the vertex factors depending on them) can be
 extended (beyond \ttt{aS} and \ttt{G}) by using
 the option \ttt{WORunParameters} when calling the
 interface~\footnote{As the legacy branch, \whizard\ttt{1}, does not
   support a running strong coupling, this is also vetoed by the
   interface when using \whizard \ttt{1.x}.}.
 
 \paragraph{\bf Gauge choices:}
 \label{sec:gauge-choices}
 
 The interface supports the unitarity, Feynman and $R_\xi$ gauges. The choice of
 gauge must be communicated to the interface via the option \ttt{WOGauge}.
 Note that massless gauge bosons are always treated in Feynman gauge.
 
 If the selected gauge is Feynman or $R_\xi$, the interface can
 automatically assign the proper masses to the Goldstone bosons. This behavior is
 requested by using the \ttt{WOAutoGauge} option. In the $R_\xi$
 gauges, the symbol representing the gauge $\xi$ must be communicated to the
 interface by using the \ttt{WOGaugeSymbol} option (the symbol is
 automatically introduced into the list of external
 parameters if \ttt{WOAutoGauge} is
 selected at the same time). This feature can be used to automatically extend
 models implemented in Feynman gauge to the $R_\xi$ gauges.
 
 Since \whizard\ (at least until the release series 2.3) is a
 tree-level tool working with helicity amplitudes, the ghost sector is
 irrelevant for \whizard\ and hence dropped by the interface.
 
 \subsection{Options of the \whizard-\FeynRules\ interface}
 \label{app:interface-options}
 
 In the following we present a comprehensive list of all the options accepted by
 \ttt{WriteWOOutput}. Additionally, we note that all options of the
 \FeynRules\ command \ttt{FeynmanRules} are accepted by
 \ttt{WriteWOOutput}, which passes them on to \ttt{FeynmanRules}.
 
 \begin{description}
 \item[\ttt{Input}]\mbox{}\\
 An optional vertex list to use instead of a Lagrangian (which can then be
 omitted).
 %
 \item[\ttt{WOWhizardVersion}]\mbox{}\\
 Select the \whizard\ version for which code is to be generated.
 The currently available choices are summarized in
 Tab.~\ref{tab-wowhizardversion}.
 %%
 \begin{table}
 \centerline{\begin{tabular}{|l|l|}
 \hline \ttt{WOWhizardVersion} & \whizard\ versions supported
 \\\hline\hline
 \ttt{"2.0.3"} (default) & 2.0.3+ \\\hline
 \ttt{"2.0"} & 2.0.0 -- 2.0.2 \\\hline\hline
 \ttt{"1.96"} & 1.96+ \qquad (deprecated) \\\hline
 \ttt{"1.93"} & 1.93 -- 1.95 \qquad (deprecated) \\\hline
 \ttt{"1.92"} & 1.92 \qquad (deprecated) \\\hline
 \end{tabular}}
 \caption{Currently available choices for the \ttt{WOWhizardVersion} option,
 together with the respective \whizard\ versions supported by them.}
 \label{tab-wowhizardversion}
 \end{table}
 %%
 This list  will expand as the program evolves. To get a summary
 of all choices available in a particular version of the interface, use
 the command
 \ttt{?WOWhizardVersion}.
 %
 \item[\ttt{WOModelName}]\mbox{}\\
 The name under which the model will be known to
 \whizard\footnote{For versions 1.9x, model names must start
   with ``\ttt{fr\_}'' if they are to be picked up by \whizard\
   automatically.}. The default is determined from the \FeynRules\
 model name.
 %
 \item[\ttt{Output}]\mbox{}\\
 The name of the output directory. The default is determined from the
 \FeynRules\ model name.
 %
 \item[\ttt{WOGauge}]\mbox{}\\
 Gauge choice (\emph{cf.} Sec.~\ref{sec:gauge-choices}).
 Possible values are: \ttt{WOUnitarity} (default),
 \ttt{WOFeynman}, \ttt{WORxi}
 %
 \item[\ttt{WOGaugeParameter}]\mbox{}\\
 The external or internal parameter representing the gauge $\xi$ in
 the $R_\xi$ gauges (\emph{cf.} Sec.~\ref{sec:gauge-choices}). Default:
 \ttt{Rxi}
 %
 \item[\ttt{WOAutoGauge}]\mbox{}\\
 Automatically assign the Goldstone boson masses in the Feynman and $R_\xi$
 gauges and automatically append the symbol for $\xi$ to the parameter list in
 the $R_\xi$ gauges. Default: \ttt{False}
 %
 \item[\ttt{WORunParameters}]\mbox{}\\
 The list of all internal parameters which will be recalculated if $\alpha_S$ is
 evolved (see above)\footnote{Not available for versions older than
   2.0.0}. Default: \mbox{\ttt{\{aS, G\}}}
 %
 \item[\ttt{WOFast}]\mbox{}\\
 If the interface drops vertices which are supported, this option can be
 set to \ttt{False} to enable some more time consuming checks which might aid
 the identification. Default: \ttt{True}
 %
 \item[\ttt{WOMaxCouplingsPerFile}]\mbox{}\\
 The maximum number of couplings that are written to a single \fortran\
 file. If compilation takes too long or fails, this can be
 lowered. Default: \ttt{500}
 %
 \item[\ttt{WOVerbose}]\mbox{}\\
 Enable verbose output and in particular more extensive information on any
 skipped vertices. Default: \ttt{False}
 \end{description}
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \subsection{Validation of the interface}
 
 The output of the interface has been extensively
 validated. Specifically, the integrated cross sections for all
 possible $2\rightarrow 2$ processes in the \FeynRules\ SM, the MSSM
 and the Three-Site Higgsless Model have been compared between
 \whizard, \madgraph, and \CalcHep, using the respective \FeynRules\
 interfaces as well as the in-house implementations of these models
 (the Three-Site Higgsless model not being available in \madgraph).
 Also, different gauges have been checked for \whizard\ and \CalcHep.
 In all comparisons, excellent agreement within the Monte Carlo errors
 was achieved. The detailed comparison including examples of the
 comparison tables can be found in~\cite{Christensen:2010wz}.
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \subsection{Examples for the \whizard-/\FeynRules\ interface}
 
 Here, we will use the Standard Model, the MSSM and the Three-Site
 Higgsless Model as prime examples to explain the usage of the
 interface. Those are the models that have been used in the validation
 of the interface in~\cite{Christensen:2010wz}. The examples are
 constructed to show the application of the different options of the
 interface and to serve as a starting point for the generation of the
 user's own \whizard\ versions of other \FeynRules\ models.
 
 \subsubsection{\whizard-\FeynRules\ example: Standard
   Model}\label{sec:usageSM}
 
 To start off, we will create {\sc Whizard} 2 versions of the Standard
 Model as implemented in \FeynRules\ for different gauge choices.
 
 \paragraph{SM: Unitarity Gauge}
 
 In order to invoke \FeynRules, we change to the corresponding
 directory and load the program in \Mathematica\ via
 \begin{code}
 $FeynRulesPath =
      SetDirectory["<path-to-FeynRules>"];
 <<FeynRules`
 \end{code}
 %$
 The model is loaded by
 \begin{code}
 LoadModel["Models/SM/SM.fr"];
 FeynmanGauge = False;
 \end{code}
 Note that the second line is required to switch the Standard
 Model to Unitarity gauge as opposed to Feynman gauge (which is the default).
 Generating a \whizard\ model is now simply done by
 \begin{code}
 WriteWOOutput[LSM];
 \end{code}
 After invokation, the interface first gives a short summary of the setup
 \begin{code}
 Short model name is "fr_standard_model"
 Gauge: Unitarity
 Generating code for WHIZARD / O'Mega
                         version 2.0.3
 Maximum number of couplings per FORTRAN
                            module: 500
 Extensive lorentz structure checks disabled.
 \end{code}
 
 Note that, as we have not changed any options, those settings represent the
 defaults. The output proceeds with the calculation of the Feynman rules from the
 Standard Model Lagrangian \verb?LSM?. After the rules have been derived, the
 interface starts generating output and tries to match the vertices to
 their \whizard/\oMega\ counterparts.
 \begin{code}
    10 of 75 vertices processed...
    20 of 75 vertices processed...
    30 of 75 vertices processed...
    40 of 75 vertices processed...
    50 of 75 vertices processed...
    60 of 75 vertices processed...
    70 of 75 vertices processed...
 processed a total of 75 vertices, kept 74
    of them and threw away 1, 1 of which
    contained ghosts or goldstone bosons.
 \end{code}
 The last line of the above output is particularily interesting, as it informs us
 that everything worked out correctly: the interface was able to match all
 vertices, and the only discarded vertex was the QCD ghost interaction.
 After the interface has finished running, the model files in the output
 directory are ready to use and can be compiled using the procedure described in
 the previous section.
 
 %%%%%
 
 \paragraph{SM: Feynman and $R_\xi$ gauges}
 
 As the Standard Model as implemented in \FeynRules\ also supports Feynman
 gauge, we can use the program to generate a Feynman gauge version of the model.
 Loading \FeynRules\ and the model proceeds as above, with the only
 difference being the change
 \begin{code}
 FeynmanGauge = True;
 \end{code}
 In order to inform the interface about the modified gauge, we have to
 add the option \verb?WOGauge?
 \begin{code}
 WriteWOOutput[LSM, WOGauge -> WOFeynman];
 \end{code}
 The modified gauge is reflected in the output of the interface
 \begin{code}
 Short model name is "fr_standard_model"
 Gauge: Feynman
 Generating code for WHIZARD / O'Mega
                         version 2.0.3
 Maximum number of couplings per FORTRAN
                            module: 500
 Extensive lorentz structure checks disabled.
 \end{code}
 The summary of the vertex identification now takes the following form
 \begin{code}
 processed a total of 163 vertices, kept 139
    of them and threw away 24, 24 of which
    contained ghosts.
 \end{code}
 Again, this line tells us that there were no problems --- the only
 discarded interactions involved the ghost sector which is irrelevant
 for the tree-level part of \whizard.
 
 For a tree-level calculation, the only difference between the
 different gauges from the perspective of the interface are the gauge
 boson propagators and the Goldstone boson masses. Therefore, the
 interface can automatically convert a model in Feynman gauge to a
 model in $R_\xi$ gauge. To this end, the call to the interface must be
 changed to
 \begin{code}
 WriteWOOutput[LSM, WOGauge -> WORxi,
                WOAutoGauge -> True];
 \end{code}
 The \verb?WOAutoGauge? argument instructs the interface to
 automatically
 \begin{enumerate}
 \item Introduce a symbol for the gauge parameter $\xi$ into the
 list of external parameters
 \item Generate the Goldstone boson masses from those of the associated
   gauge bosons (ignoring the values provided by \FeynRules)
 \end{enumerate}
 The modified setup is again reflected in the interface output
 \begin{code}
 Short model name is "fr_standard_model"
 Gauge: Rxi
 Gauge symbol: "Rxi"
 Generating code for WHIZARD / O'Mega
                        version 2.0.3
 Maximum number of couplings per FORTRAN
                          module: 500
 Extensive lorentz structure checks disabled.
 \end{code}
 Note the default choice \verb?Rxi? for the name of the $\xi$ parameter
 -- this can be modified via the option \verb?WOGaugeParameter?.
 
 While the \verb?WOAutoGauge? feature allows to generate $R_\xi$ gauged models
 from models implemented in Feynman gauge, it is of course also possible to use
 models genuinely implemented in $R_\xi$ gauge by setting this parameter to
 \verb?False?. Also, note that the choice of gauge only affects the propagators
 of massive fields. Massless gauge bosons are always treated in Feynman
 gauge.
 
 \paragraph{Compilation and usage}
 
 In order to compile and use the freshly generated model files, change to the
 output directory which can be determined from the interface output (in this
 example, it is \verb?fr_standard_model-WO?). Assuming that \whizard\ is
 available in the binary search path, compilation and installation proceeds as
 described above by executing
 \begin{code}
 ./configure && make && make install
 \end{code}
 The model is now ready and can be used similarly to the builtin
 \whizard\ models. For example, a minimal \whizard\ input file for
 calculating the $e^+e^- \longrightarrow W^+W^-$ scattering cross
 section in the freshly generated model would look like
 \begin{code}
 model = fr_standard_model
 process test = "e+", "e-" -> "W+", "W-"
 sqrts = 500 GeV
 integrate (test)
 \end{code}
 
 %%%%%
 
 \subsubsection{\whizard/\FeynRules\ example: MSSM}
 In this Section, we illustrate the usage of the interface between {\sc
 FeynRules} and {\sc Whizard} in the context of the MSSM. All the
 parameters of the model are then ordered in Les Houches blocks and
 counters following the SUSY Les Houches Accord (SLHA)
 \cite{Skands:2003cj,AguilarSaavedra:2005pw,Allanach:2008qq} (cf. also
 Sec.~\ref{sec:slha}).
 
 After having downloaded the model
 from the \FeynRules\ website, we store it in a new directory, labelled
 \verb"MSSM", of the model library of the local installation of
 \FeynRules. The model can then be loaded in \Mathematica\ as in the
 case of the SM example above
 \begin{code}
 $FeynRulesPath =
         SetDirectory["<path-to-FeynRules>"];
 <<FeynRules`
 LoadModel["Models/MSSM/MSSM.fr"];
 FeynmanGauge = False;
 \end{code}
 %$
 We are again adopting unitarity gauge.
 
 The number of vertices associated to supersymmetric Lagrangians is in general
 very large (several thousands). For such models with many interactions,
 it is recommended to first extract all the Feynman rules of the theory before
 calling the interface between \whizard\ and \FeynRules.
 The reason is related to the efficiency of the interface  which takes
 a lot of time in the extraction of the interaction vertices. In the
 case one wishes to study the phenomenology of several benchmark
 scenarios, this procedure, which is illustrated below,
 allows to use the interface in the best way. The Feynman rules
 are derived from the Lagrangian once and for all and then reused by the
 interface for each set of \whizard\ model files to be produced,
 considerably  speeding up the generation of multiple model files
 issued from a single Lagrangian. In addition, the scalar potential of
 supersymmetric theories contains a large set of four scalar
 interactions, in general irrelevant for collider phenomenology. These
 vertices can be neglected with the help of the
 \verb"Exclude4Scalars->True" option of both interface commands
 \verb"FeynmanRules" and \verb"WriteWOOutput". The Feynman
 rules of the MSSM are then computed within the \Mathematica\ notebook
 by
 \begin{code}
 rules = FeynmanRules[lag,
    Exclude4Scalars->True, FlavorExpand->True];
 \end{code}
 where \verb'lag' is the variable containing the Lagrangian.
 
 By default, all the parameters of the model are set to the value of
 \ttt{1}. A complete parameter \ttt{{\em <slha\_params>}.dat} file
 must therefore be loaded. Such a parameter file can be downloaded from
 the \FeynRules\ website or created by hand by the user, and loaded
 into \FeynRules\ as
 \begin{code}
 ReadLHAFile[Input -> "<slha_params>.dat"];
 \end{code}
 This command does not reduce the size of the model output by removing
 vertices with vanishing couplings.  However, if desired, this task
 could be done with the  \ttt{LoadRestriction} command (see Ref.\
 \cite{Fuks:2012im} for details).
 
 The vertices are exported to \whizard\ by the command
 \begin{code}
 WriteWOOutput[Input -> rules];
 \end{code}
 Note that the numerical values of the parameters of the model can be
 modified directly from \whizard, without having to generate a second
 time the \whizard\ model files from \FeynRules. A \sindarin\ script is
 created by the interface with the help of the instruction
 \begin{code}
 WriteWOExtParams["parameters.sin"];
 \end{code}
 and can be further modified according to the needs of the user.
 
 \subsubsection{\whizard-\FeynRules\ example: Three-Site Higgsless Model}
 
 
 The Three-Site Higgsless model or Minimal Higgsless model (MHM) has
 been implemented into \ttt{LanHEP}~\cite{He:2007ge}, \FeynRules\
 and independently into \whizard~\cite{Speckner:2010zi},
 and the collider phenomenology has been studied by making use of these
 implementations \cite{He:2007ge,Ohl:2010zf,Speckner:2010zi}.
 Furthermore, the independent implementations in \FeynRules\ and
 directly into {\sc Whizard} have been compared and found to
 agree~\cite{Christensen:2010wz}. After the discovery of a Higgs boson
 at the LHC in 2012, such a model is not in good agreement with
 experimental data any more. Here, we simply use it as a guinea pig to
 describe the handling of a model with non-renormalizable interactions
 with the \FeynRules\ interface, and discuss how to generate \whizard\
 model files for it. The model has been implemented in Feynman gauge as
 well as unitarity gauge and contains the variable \verb|FeynmanGauge|
 which can be set to \verb|True|  or \verb|False|. When set to
 \verb|True|, the option \verb|WOGauge-> WOFeynman| must be used, as
 explained in~\cite{Christensen:2010wz}. $R_\xi$ gauge can also be
 accomplished with this model by use of the options
 \verb|WOGauge -> WORxi| and \verb?WOAutoGauge -> True?.
 
 Since this model makes use of a nonlinear sigma field of the form
 \begin{equation}
 \Sigma = 1 + i\pi - \frac{1}{2}\pi^2+\cdots
 \end{equation}
 many higher dimensional operators are included in the model which are
 not currently not supported by \whizard. Even for a future release of
 \whizard\ containing general Lorentz structures in interaction
 vertices, the user would be forced to expand the series only up to a
 certain order. Although \whizard\ can reject these vertices
 and print a warning message to the user, it is preferable to remove
 the vertices right away in the interface by the option
 \verb|MaxCanonicalDimension->4|. This is passed to the command
 \verb|FeynmanRules| and restricts the Feynman rules to those of
 dimension four and smaller\footnote{\ttt{MaxCanonicalDimension} is an
   option of the \ttt{FeynmanRules} function rather than of the
   interface, itself. In fact, the interface accepts all the options of
   {\tt FeynmanRules} and simply passes them on to the latter.}.
 
 As the use of different gauges was already illustrated in the SM
 example, we discuss the model only in Feynman gauge here. We load
 \FeynRules:
 \begin{code}
 $FeynRulesPath =
      SetDirectory["<path-to-FeynRules>"];
 <<FeynRules`
 \end{code}
 %$
 The MHM model itself is then loaded by
 \begin{code}
 SetDirectory["<path-to-MHM>"];
 LoadModel["3-Site-particles.fr",
    "3-Site-parameters.fr",
    "3-Site-lagrangian.fr"];
 FeynmanGauge = True;
 \end{code}
 where \verb|<path-to-MHM>| is the path to the directory where the MHM
 model files are stored and where the output of the \whizard\
 interface will be written. The \whizard\ interface is then initiated:
 \begin{code}
 WriteWOOutput[LGauge, LGold, LGhost, LFermion,
    LGoldLeptons, LGoldQuarks,
    MaxCanonicalDimension->4,
    WOGauge->WOFeynman, WOModelName->"fr_mhm"];
 \end{code}
 where we have also made use of the option \verb|WOModelName| to change
 the name of the model as seen by \whizard. As in the case of the SM,
 the interface begins by writing a short informational message:
 \begin{code}
 Short model name is "fr_mhm"
 Gauge: Feynman
 Generating code for WHIZARD / O'Mega
                        version 2.0.3
 Automagically assigning Goldstone
                         boson masses...
 Maximum number of couplings per FORTRAN
                         module: 500
 Extensive lorentz structure checks disabled.
 \end{code}
 After calculating the Feynman rules and processing the vertices, the
 interface gives a summary:
 \begin{code}
 processed a total of 922 vertices, kept 633
   of them and threw away 289, 289 of which
   contained ghosts.
 \end{code}
 showing that no vertices were missed.  The files are stored in the
 directory \verb|fr_mhm| and are ready to be installed and used with
 \whizard.
 
 %%%%%%%%%%%%%%%
 
 \section{New physics models via the \UFO\ file format}
 \label{sec:ufo}
 
 In this section, we describe how to use the {\em Universal FeynRules
 Output} (\UFO, \cite{Degrande:2011ua}) format for physics models
 inside \whizard. Please refer the manuals of e.g.~\FeynRules\ manual
 for details on how to generate a \UFO\ file for your favorite physics
 model. \UFO\ files are a collection of \ttt{Python} scripts that
 encode the particles, the couplings, the Lorentz structures, the
 decays, as well as parameters, vertices and propagators of the
 corresponding model. They reside in a directory of the exact name of
 the model they have been created from.
 
 If the user wants to generate events for processes from a physics
 model from a \UFO\ file, then this directory of scripts generated by
 \FeynRules\ is immediately available if it is a subdirectory of the working
 directory of \whizard.  The directory name will be taken as the model
 name. (The \UFO-model file name must not start with a
   non-letter character, i.e. especially not a number.  In case such a
   file name wants to be used at all costs, the model name in the
   \sindarin\ script has to put in quotation marks, but this is not
   guaranteed to always work.)  Then, a \UFO\ model named, e.g.,
 \ttt{test\_model} is accessed by an extra \ttt{ufo} tag in the model
 assignment:
 \begin{Code}
   model = test_model (ufo)
 \end{Code}
 
 If desired, \whizard\ can access a directory of \UFO\ files elsewhere
 on the file system.  For instance, if \FeynRules\ output resides in
 the subdirectory \ttt{MyMdl} of
 \ttt{/home/users/john/ufo}, \whizard\ can use the model
 named \ttt{MyMdl} as follows
 \begin{Code}
   model = MyMdl (ufo ('/home/users/john/my_ufo_models'))
 \end{Code}
 that is, the \sindarin\ keyword \ttt{ufo} can take an argument.  Note
 however, that the latter approach can backfire --- in case just the working
 directory is packed and archived for future reference.
 
 %%%%%%%%%%%%%%%
 
 
 
 \clearpage
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 \appendix
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \chapter{\sindarin\ Reference}
 
 In the \sindarin\ language, there are certain pre-defined constructors or
 commands that cannot be used in different context by the user, which
 are e.g. \ttt{alias}, \ttt{beams}, \ttt{integrate}, \ttt{simulate} etc.
 A complete list will be given below. Also units are fixed, like
 \ttt{degree}, \ttt{eV}, \ttt{keV},
 \ttt{MeV}, \ttt{GeV}, and \ttt{TeV}. Again, these tags are locked and
 not user-redefinable. Their functionality will be listed in detail
 below, too. Furthermore, a variable with a preceding
 question mark, ?, is a logical, while a preceding dollar, \$, denotes a
 character string variable.  Also, a lot of unary and binary operators
 exist, \ttt{+ - $\backslash$ , = : => < > <= >= \^ \;  () [] \{\} }
 \url{==}, as well as quotation marks, ". Note that the
 different parentheses and brackets fulfill different purposes, which
 will be explained below. Comments in a line can either be marked by a
 hash, \#, or an exclamation mark, !.
 
 \section{Commands and Operators}
 We begin the \sindarin\ reference with all commands, operators, functions
 and constructors.
 The list of variables (which can be set to change behavior of \whizard) can
 be found in the next section.
 \begin{itemize}
 \item
 \ttt{+} \newline
 1) Arithmetic operator for addition of integers, reals and complex
 numbers. Example: \ttt{real mm = mH + mZ} (cf. also \ttt{-}, \ttt{*},
 \ttt{/}, \ttt{\^{}}). 2) It also adds different particles for inclusive
 process containers: \ttt{process foo = e1, E1 => (e2, E2) + (e3,
   E3)}. 3) It also serves as a shorthand notation for the
 concatenation of ($\to$) \ttt{combine} operations on
 particles/subevents, e.g. \ttt{cuts = any 170 GeV < M < 180 GeV [b +
   lepton + invisible]}.
 %%%%%
 \item
 \ttt{-} \newline
 Arithmetic operator for subtraction of integers, reals and complex
 numbers. Example: \ttt{real foo = 3.1 - 5.7} (cf. also \ttt{+}, \ttt{*},
 \ttt{/}, \ttt{\^{}}).
 %%%%%
 \item
 \ttt{/} \newline
 Arithmetic operator for division of integers, reals and complex
 numbers. Example: \ttt{scale = mH / 2} (cf. also \ttt{+}, \ttt{*},
 \ttt{-}, \ttt{\^{}}).
 %%%%%
 \item
 \ttt{*} \newline
 Arithmetic operator for multiplication of integers, reals and complex
 numbers. Example: \ttt{complex z = 2 * I} (cf. also \ttt{+}, \ttt{/},
 \ttt{-}, \ttt{\^{}}).
 %%%%%
 \item
 \ttt{\^{}} \newline
 Arithmetic operator for exponentiation of integers, reals and complex
 numbers. Example: \ttt{real z = x\^{}2 + y\^{}2} (cf. also \ttt{+},
 \ttt{/}, \ttt{-}, \ttt{\^{}}).
 %%%%%
 \item
 \ttt{<} \newline
 Arithmetic comparator between values that checks for ordering
 of two values: \ttt{{\em <val1>} < {\em <val2>}} tests whether
 \ttt{{\em val1}} is smaller than \ttt{{\em val2}}. Allowed for
 integer and real values. Note that this is an exact comparison if
 \ttt{tolerance} is set to zero. For a finite value of \ttt{tolerance}
 it is a ``fuzzy'' comparison. (cf. also \ttt{tolerance}, \ttt{<>},
 \ttt{==}, \ttt{>}, \ttt{>=}, \ttt{<=})
 %%%%%
 \item
 \ttt{>} \newline
 Arithmetic comparator between values that checks for ordering
 of two values: \ttt{{\em <val1>} > {\em <val2>}} tests whether
 \ttt{{\em val1}} is larger than \ttt{{\em val2}}. Allowed for
 integer and real values. Note that this is an exact comparison if
 \ttt{tolerance} is set to zero. For a finite value of \ttt{tolerance}
 it is a ``fuzzy'' comparison. (cf. also \ttt{tolerance}, \ttt{<>},
 \ttt{==}, \ttt{>}, \ttt{>=}, \ttt{<=})
 %%%%%
 \item
 \ttt{<=} \newline
 Arithmetic comparator between values that checks for ordering
 of two values: \ttt{{\em <val1>} <= {\em <val2>}} tests whether
 \ttt{{\em val1}} is smaller than or equal \ttt{{\em val2}}. Allowed for
 integer and real values. Note that this is an exact comparison if
 \ttt{tolerance} is set to zero. For a finite value of \ttt{tolerance}
 it is a ``fuzzy'' comparison. (cf. also \ttt{tolerance}, \ttt{<>},
 \ttt{==}, \ttt{>}, \ttt{<}, \ttt{>=})
 %%%%%
 \item
 \ttt{>=} \newline
 Arithmetic comparator between values that checks for ordering
 of two values: \ttt{{\em <val1>} >= {\em <val2>}} tests whether
 \ttt{{\em val1}} is larger than or equal \ttt{{\em val2}}. Allowed for
 integer and real values. Note that this is an exact comparison if
 \ttt{tolerance} is set to zero. For a finite value of \ttt{tolerance}
 it is a ``fuzzy'' comparison. (cf. also \ttt{tolerance}, \ttt{<>},
 \ttt{==}, \ttt{>}, \ttt{<}, \ttt{>=})
 %%%%%
 \item
 \ttt{==} \newline
 Arithmetic comparator between values that checks for identity
 of two values: \ttt{{\em <val1>} == {\em <val2>}}. Allowed for
 integer and real values. Note that this is an exact comparison if
 \ttt{tolerance} is set to zero. For a finite value of \ttt{tolerance}
 it is a ``fuzzy'' comparison. (cf. also \ttt{tolerance}, \ttt{<>},
 \ttt{>}, \ttt{<}, \ttt{>=}, \ttt{<=})
 %%%%%
 \item
 \ttt{<>} \newline
 Arithmetic comparator between values that checks for
 two values being unequal: \ttt{{\em <val1>} <> {\em <val2>}}. Allowed for
 integer and real values. Note that this is an exact comparison if
 \ttt{tolerance} is set to zero. For a finite value of \ttt{tolerance}
 it is a ``fuzzy'' comparison. (cf. also \ttt{tolerance}, \ttt{==},
 \ttt{>}, \ttt{<}, \ttt{>=}, \ttt{<=})
 %%%%%
 \item
 \ttt{!} \newline
 The exclamation mark tells \sindarin\ that everything that follows in
 that line should be treated as a comment. It is the same as ($\to$)
 \ttt{\#}.
 %%%%%
 \item
 \ttt{\#} \newline
 The hash tells \sindarin\ that everything that follows in
 that line should be treated as a comment. It is the same as ($\to$)
 \ttt{!}.
 %%%%%
 \item
 \ttt{\&} \newline
 Concatenates two or more particle lists/subevents and hence acts in
 the same way as the subevent function ($\to$) \ttt{join}: \ttt{let
 @visible = [photon] \& [colored] \& [lepton] in ...}. (cf. also
 \ttt{join}, \ttt{combine}, \ttt{collect}, \ttt{extract}, \ttt{sort}).
 %%%%%
 \item
 \ttt{\$} \newline
 Constructor at the beginning of a variable name,
 \ttt{\${\em <string\_var>}}, that specifies a string variable.
 %%%%%
 \item
 \ttt{@} \newline
 Constructor at the beginning of a variable name, \ttt{@{\em
 <subevt\_var>}}, that specifies a subevent variable, e.g. \ttt{let
 @W\_candidates = combine ["mu-", "numubar"] in ...}.
 %%%%%
 \item
 \ttt{=} \newline
 Binary constructor to appoint values to commands, e.g. \ttt{{\em <command>}
   = {\em <expr>}} or \newline \ttt{{\em <command>} {\em <var\_name>} =
   {\em <expr>}}.
 %%%%%
 \item
 \ttt{\%} \newline
 Constructor that gives the percentage of a number, so in
 principle multiplies a real number by \ttt{0.01}. Example: \ttt{1.23
   \%} is equal to \ttt{0.0123}.
 %%%%%
 \item
 \ttt{:} \newline
 Separator in alias expressions for particles, e.g. \ttt{alias neutrino
   = n1:n2:n3:N1:N2:N3}. (cf. also \ttt{alias})
 %%%%%
 \item
 \ttt{;} \newline
 Concatenation operator for logical expressions: \ttt{{\em lexpr1} ;
   {\em lexpr2}}. Evaluates \ttt{{\em lexpr1}} and throws the result
 away, then evaluates \ttt{{\em lexpr2}} and returns that result. Used
 in analysis expressions. (cf. also \ttt{analysis}, \ttt{record})
 %%%%%
 \item
 \ttt{/+} \newline
 Incrementor for ($\to$) \ttt{scan} ranges, that increments additively,
 \ttt{scan {\em <num\_spec> <num>} = ({\em <lower val>} => {\em <upper
     val>} /+ {\em <step
 size>})}. E.g. \ttt{scan int i = (1 => 5 /+ 2)} scans over the values \ttt{1},
 \ttt{3}, \ttt{5}. For real ranges, it divides the interval between
 upper and lower bound into as many intervals as the incrementor
 provides, e.g. \ttt{scan real r = (1 => 1.5 /+ 0.2)} runs over
 \ttt{1.0}, \ttt{1.333}, \ttt{1.667}, \ttt{1.5}.
 %%%%%
 \item
 \ttt{/+/} \newline
 Incrementor for ($\to$) \ttt{scan} ranges, that increments additively,
 but the number after the incrementor is the number of steps, not the
 step size: \ttt{scan {\em <num\_spec> <num>} = ({\em <lower val>} =>
   {\em <upper val>}
 /+/ {\em <steps>})}. It is only available for real scan ranges, and divides
 the interval \ttt{{\em <upper val>} - {\em <lower val>}} into
 \ttt{{\em <steps>}} steps,
 e.g. \ttt{scan real r = (1 => 1.5 /+/ 3)} runs over \ttt{1.0},
 \ttt{1.25}, \ttt{1.5}.
 %%%%%
 \item
 \ttt{/-} \newline
 Incrementor for ($\to$) \ttt{scan} ranges, that increments subtractively,
 \ttt{scan {\em <num\_spec>} {\em <num>} = ({\em <lower val>} => {\em <upper val>} /- {\em <step
 size>})}. E.g. \ttt{scan int i = (9 => 0 /+ 3)} scans over the values \ttt{9},
 \ttt{6}, \ttt{3}, \ttt{0}. For real ranges, it divides the interval
 between upper and lower bound into as many intervals as the incrementor
 provides, e.g. \ttt{scan real r = (1 => 0.5 /- 0.2)} runs over
 \ttt{1.0}, \ttt{0.833}, \ttt{0.667}, \ttt{0.5}.
 %%%%%
 \item
 \ttt{/*} \newline
 Incrementor for ($\to$) \ttt{scan} ranges, that increments multiplicatively,
 \ttt{scan {\em <num\_spec>} {\em <num>} = ({\em <lower val>} => {\em <upper val>} /* {\em <step
 size>})}. E.g. \ttt{scan int i = (1 => 4 /* 2)} scans over the values \ttt{1},
 \ttt{2}, \ttt{4}. For real ranges, it divides the interval
 between upper and lower bound into as many intervals as the incrementor
 provides, e.g. \ttt{scan real r = (1 => 5 /* 2)} runs over
 \ttt{1.0}, \ttt{2.236} (i.e. $\sqrt{5}$), \ttt{5.0}.
 %%%%%
 \item
 \ttt{/*/} \newline
 Incrementor for ($\to$) \ttt{scan} ranges, that increments multiplicatively,
 but the number after the incrementor is the number of steps, not the
 step size: \ttt{scan {\em <num\_spec>} {\em <num>} = ({\em <lower val>} => {\em <upper val>}
 /*/ {\em <steps>})}. It is only available for real scan ranges, and divides
 the interval \ttt{{\em <upper val>} - {\em <lower val>}} into \ttt{{\em <steps>}} steps,
 e.g. \ttt{scan real r = (1 => 9 /*/ 4)} runs over \ttt{1.000},
 \ttt{2.080}, \ttt{4.327}, \ttt{9.000}.
 %%%%%
 \item
 \ttt{//} \newline
 Incrementor for ($\to$) \ttt{scan} ranges, that increments by division,
 \ttt{scan {\em <num\_spec>} {\em <num>} = ({\em <lower val>} => {\em <upper val>} // {\em <step
 size>})}. E.g. \ttt{scan int i = (13 => 0 // 3)} scans over the values \ttt{13},
 \ttt{4}, \ttt{1}, \ttt{0}. For real ranges, it divides the interval
 between upper and lower bound into as many intervals as the incrementor
 provides, e.g. \ttt{scan real r = (5 => 1 // 2)} runs over
 \ttt{5.0}, \ttt{2.236} (i.e. $\sqrt{5}$), \ttt{1.0}.
 %%%%%
 \item
 \ttt{=>} \newline
 Binary operator that is used in several different contexts: 1) in
 process declarations between the particles specifying the
 initial and final state, e.g. \ttt{process {\em <proc\_name>} = {\em <in1>}, {\em <in2>}
 => {\em <out1>}, ....}; 2) for the specification of beams when
 structure functions are applied to the beam particles, e.g. \ttt{beams
 = p, p => pdf\_builtin}; 3) for the specification of the scan range in
 the \ttt{scan {\em <var>} {\em <var\_name>} = ({\em <scan\_start>} => {\em <scan\_end>}
   {\em <incrementor>})} (cf. also \ttt{process}, \ttt{beams}, \ttt{scan})
 %%%%%
 \item
 \ttt{\%d} \newline
 Format specifier in analogy to the \ttt{C} language for the print out
 on screen by the ($\to$) \ttt{printf} or into strings by the ($\to$)
 \ttt{sprintf} command. It is used for decimal integer numbers,
 e.g. \ttt{printf "one = \%d" (i)}. The difference between \ttt{\%i}
 and \ttt{\%d} does not play a role here. (cf. also \ttt{printf}, \ttt{sprintf},
 \ttt{\%i}, \ttt{\%e}, \ttt{\%f}, \ttt{\%g}, \ttt{\%E}, \ttt{\%F},
 \ttt{\%G}, \ttt{\%s})
 %%%%%
 \item
 \ttt{\%e} \newline
 Format specifier in analogy to the \ttt{C} language for the print out
 on screen by the ($\to$) \ttt{printf} or into strings by the ($\to$)
 \ttt{sprintf} command. It is used for floating-point numbers in
 standard form \ttt{[-]d.ddd e[+/-]ddd}. Usage e.g. \ttt{printf "pi =
 \%e" (PI)}.  (cf. also \ttt{printf}, \ttt{sprintf},
 \ttt{\%d}, \ttt{\%i}, \ttt{\%f}, \ttt{\%g}, \ttt{\%E}, \ttt{\%F},
 \ttt{\%G}, \ttt{\%s})
 %%%%%
 \item
 \ttt{\%E} \newline
 Same as ($\to$) \ttt{\%e}, but using upper-case letters.  (cf. also
 \ttt{printf}, \ttt{sprintf}, \ttt{\%d}, \ttt{\%i}, \ttt{\%e}, \ttt{\%f},
 \ttt{\%g}, \ttt{\%F}, \ttt{\%G}, \ttt{\%s})
 %%%%%
 \item
 \ttt{\%f} \newline
 Format specifier in analogy to the \ttt{C} language for the print out
 on screen by the ($\to$) \ttt{printf} or into strings by the ($\to$)
 \ttt{sprintf} command. It is used for floating-point numbers in
 fixed-point form. Usage e.g. \ttt{printf "pi =
 \%f" (PI)}.  (cf. also \ttt{printf}, \ttt{sprintf},
 \ttt{\%d}, \ttt{\%i}, \ttt{\%e}, \ttt{\%g}, \ttt{\%E}, \ttt{\%F},
 \ttt{\%G}, \ttt{\%s})
 %%%%%
 \item
 \ttt{\%F} \newline
 Same as ($\to$) \ttt{\%f}, but using upper-case letters.  (cf. also
 \ttt{printf}, \ttt{sprintf}, \ttt{\%d}, \ttt{\%i}, \ttt{\%e}, \ttt{\%f},
 \ttt{\%g}, \ttt{\%E}, \ttt{\%G}, \ttt{\%s})
 %%%%%
 \item
 \ttt{\%g} \newline
 Format specifier in analogy to the \ttt{C} language for the print out
 on screen by the ($\to$) \ttt{printf} or into strings by the ($\to$)
 \ttt{sprintf} command. It is used for floating-point numbers in
 normal or exponential notation, whichever is more approriate. Usage
 e.g. \ttt{printf "pi = \%g" (PI)}.  (cf. also \ttt{printf}, \ttt{sprintf},
 \ttt{\%d}, \ttt{\%i}, \ttt{\%e}, \ttt{\%f}, \ttt{\%E}, \ttt{\%F},
 \ttt{\%G}, \ttt{\%s})
 %%%%%
 \item
 \ttt{\%G} \newline
 Same as ($\to$) \ttt{\%g}, but using upper-case letters.  (cf. also
 \ttt{printf}, \ttt{sprintf}, \ttt{\%d}, \ttt{\%i}, \ttt{\%e}, \ttt{\%f},
 \ttt{\%g}, \ttt{\%E}, \ttt{\%F}, \ttt{\%s})
 %%%%%
 \item
 \ttt{\%i} \newline
 Format specifier in analogy to the \ttt{C} language for the print out
 on screen by the ($\to$) \ttt{printf} or into strings by the ($\to$)
 \ttt{sprintf} command. It is used for integer numbers,
 e.g. \ttt{printf "one = \%i" (i)}. The difference between \ttt{\%i}
 and \ttt{\%d} does not play a role here. (cf. \ttt{printf}, \ttt{sprintf},
 \ttt{\%d}, \ttt{\%e}, \ttt{\%f}, \ttt{\%g}, \ttt{\%E}, \ttt{\%F},
 \ttt{\%G}, \ttt{\%s})
 %%%%%
 \item
 \ttt{\%s} \newline
 Format specifier in analogy to the \ttt{C} language for the print out
 on screen by the ($\to$) \ttt{printf} or into strings by the ($\to$)
 \ttt{sprintf} command. It is used for logical or string variables
 e.g. \ttt{printf "foo = \%s" (\$method)}. (cf. \ttt{printf}, \ttt{sprintf},
 \ttt{\%d}, \ttt{\%i}, \ttt{\%e}, \ttt{\%f}, \ttt{\%g}, \ttt{\%E}, \ttt{\%F},
 \ttt{\%G})
 %%%%%
 \item
 \ttt{abarn} \newline
 Physical unit, stating that a number is in attobarns ($10^{-18}$
 barn). (cf. also \ttt{nbarn}, \ttt{fbarn}, \ttt{pbarn})
 %%%%%
 \item
 \ttt{abs} \newline
 Numerical function that takes the absolute value of its argument:
 \ttt{abs ({\em <num\_val>})} yields \ttt{|{\em
 <num\_val>}|}. (cf. also \ttt{conjg}, \ttt{sgn}, \ttt{mod}, \ttt{modulo})
 %%%%%
 \item
 \ttt{acos} \newline
 Numerical function \ttt{asin ({\em <num\_val>})} that calculates the
 arccosine trigonometric function (inverse of \ttt{cos}) of real and
 complex numerical numbers or variables. (cf. also \ttt{sin},
 \ttt{cos}, \ttt{tan}, \ttt{asin}, \ttt{atan})
 %%%%%
 \item
 \ttt{alias} \newline
 This allows to define a collective expression for a class of
 particles, e.g. to define a generic expression for leptons, neutrinos
 or a jet as \ttt{alias lepton = e1:e2:e3:E1:E2:E3}, \ttt{alias
 neutrino = n1:n2:n3:N1:N2:N3}, and \ttt{alias jet =
 u:d:s:c:U:D:S:C:g}, respectively.
 %%%%%
 \item
 \ttt{all} \newline
 \ttt{all} is a function that works on a logical expression and a list,
 \ttt{all {\em <log\_expr>} [{\em <list>}]}, and returns \ttt{true} if and only if
 \ttt{log\_expr} is fulfilled for {\em all} entries in \ttt{list}, and
 \ttt{false} otherwise. Examples: \ttt{all Pt > 100 GeV [lepton]}
 checks whether all leptons are harder than 100 GeV, \ttt{all Dist > 2
   [u:U, d:D]} checks whether all pairs of corresponding quarks
 are separated in $R$ space by more than 2. Logical expressions with
 \ttt{all} can be logically combined with \ttt{and} and
 \ttt{or}. (cf. also \ttt{any}, \ttt{and}, \ttt{no}, and \ttt{or})
 %%%%%
 \item
 \ttt{alt\_setup} \newline
 This command allows to specify alternative setups for a process/list
 of processes, \ttt{alt\_setup = \{ {\em <setup1>} \} [, \{ {\em <setup2>} \} ,
   ...]}. An alternative setup can be a resetting of a coupling
 constant, or different cuts etc. It can be particularly used in a
 ($\to$) \ttt{rescan} procedure.
 %%%%%
 \item
 \ttt{analysis} \newline
 This command, \ttt{analysis = {\em <log\_expr>}}, allows to define an
 analysis as a logical expression, with a syntax similar to the ($\to$)
 \ttt{cuts} or ($\to$) \ttt{selection} command. Note that a ($\to$)
 formally is a logical expression.
 %%%%%
 \item
 \ttt{and} \newline
 This is the standard two-place logical connective that has the value
 true if both of its operands are true, otherwise a value of false. It
 is applied to logical values, e.g. cut expressions. (cf. also
 \ttt{all}, \ttt{no}, \ttt{or}).
 %%%%%
 \item
 \ttt{any} \newline
 \ttt{any} is a function that works on a logical expression and a list,
 \ttt{any {\em <log\_expr>} [{\em <list>}]}, and returns \ttt{true} if
 \ttt{log\_expr} is fulfilled for any entry in \ttt{list}, and
 \ttt{false} otherwise. Examples: \ttt{any PDG == 13 [lepton]} checks
 whether any lepton is a muon, \ttt{any E > 2 * mW [jet]} checks
 whether any jet has an energy of twice the $W$ mass. Logical
 expressions with \ttt{any} can be logically combined with \ttt{and}
 and \ttt{or}. (cf. also \ttt{all}, \ttt{and}, \ttt{no}, and \ttt{or})
 %%%%%
 \item
 \ttt{as} \newline
 cf. \ttt{compile}
 %%%%%
 \item
 \ttt{ascii} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of the standard \whizard\ verbose/debug ASCII event
 files. (cf. also \ttt{\$sample}, \ttt{\$sample\_normalization},
 \ttt{sample\_format})
 %%%%%
 \item
 \ttt{asin} \newline
 Numerical function \ttt{asin ({\em <num\_val>})} that calculates the
 arcsine trigonometric function (inverse of \ttt{sin}) of real and
 complex numerical numbers or variables. (cf. also \ttt{sin},
 \ttt{cos}, \ttt{tan}, \ttt{acos}, \ttt{atan})
 %%%%%
 \item
 \ttt{atan} \newline
 Numerical function \ttt{atan ({\em <num\_val>})} that calculates the
 arctangent trigonometric function (inverse of \ttt{tan}) of real and
 complex numerical numbers or variables. (cf. also \ttt{sin},
 \ttt{cos}, \ttt{tan}, \ttt{asin}, \ttt{acos})
 %%%%%
 \item
 \ttt{athena} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of the ATHENA variant for HEPEVT ASCII event
 files. (cf. also \ttt{\$sample}, \ttt{\$sample\_normalization},
 \ttt{sample\_format})
 %%%%%
 \item
 \ttt{beam} \newline
 Constructor that specifies a particle (in a subevent) as beam particle. It is
 used in cuts, analyses or selections, e.g. \ttt{cuts = all Theta > 20
 degree [beam lepton, lepton]}. (cf. also \ttt{incoming}, \ttt{outgoing},
 \ttt{cuts}, \ttt{analysis}, \ttt{selection}, \ttt{record})
 %%%%%
 \item
 \ttt{beam\_events} \newline
 Beam structure specifier to read in lepton collider beamstrahlung's
 spectra from external files as pairs of energy fractions: \ttt{beams:
   e1, E1 => beam\_events}. Note that this is a pair spectrum that has to
 be applied to both beams simultaneously. (cf. also \ttt{beams},
 \ttt{\$beam\_events\_file}, \ttt{?beam\_events\_warn\_eof})
 %%%%%
 \item
 \ttt{beams} \newline
 This specifies the contents and structure of the beams: \ttt{beams =
   {\em <prt1>}, {\em <prt2>} [ => {\em <str\_fun1>} ....]}. If this
 command is absent in the input file, \whizard\ automatically takes the
 two incoming partons (or one for decays) of the corresponding process
 as beam particles, and no structure functions are applied. Protons and
 antiprotons as beam particles are predefined as \ttt{p} and
 \ttt{pbar}, respectively. A structure function, like \ttt{pdf\_builtin},
 \ttt{ISR}, \ttt{EPA} and so on are switched on as e.g. \ttt{beams = p,
 p => lhapdf}. Structure functions can be specified for one of the two
 beam particles only, of the structure function is not a
 spectrum. (cf. also \ttt{beams\_momentum}, \ttt{beams\_theta},
 \ttt{beams\_phi}, \ttt{beams\_pol\_density},
 \ttt{beams\_pol\_fraction}, \ttt{beam\_events}, \ttt{circe1},
 \ttt{circe2}, \ttt{energy\_scan}, \ttt{epa}, \ttt{ewa}, \ttt{isr},
 \ttt{lhapdf}, \ttt{pdf\_builtin}).
 %%%%%
 \item
 \ttt{beams\_momentum} \newline
 Command to set the momenta (or energies) for the two beams of a
 scattering process: \ttt{beams\_momentum = {\em <mom1>}, {\em <mom2>}} to allow
 for asymmetric beam setups (e.g. HERA: \ttt{beams\_momentum = 27.5
   GeV, 920 GeV}). Two arguments must be present
 for a scattering process, but the command can be used with one
 argument to integrate and simulate a decay of a moving
 particle. (cf. also \ttt{beams}, \ttt{beams\_theta},
 \ttt{beams\_phi}, \ttt{beams\_pol\_density},
 \ttt{beams\_pol\_fraction})
 %%%%%
 \item
 \ttt{beams\_phi} \newline
 Same as ($\to$) \ttt{beams\_theta}, but to allow for a non-vanishing
 beam azimuth angle, too. (cf. also \ttt{beams}, \ttt{beams\_theta},
 \ttt{beams\_momentum}, \ttt{beams\_pol\_density},
 \ttt{beams\_pol\_fraction})
 %%%%%
 \item
 \ttt{beams\_pol\_density} \newline
 This command allows to specify the initial state for polarized beams
 by the syntax: \ttt{beams\_pol\_density = @({\em <pol\_spec\_1>}),
   @({\em <pol\_spec\_2>})}. Two polarization specifiers are mandatory for
 scattering, while one can be used for decays from polarized
 probes. The specifier \ttt{{\em <pol\_spec\_i>}} can be empty (no
 polarization), has one entry (for a definite helicity/spin
 orientation), or ranges of entries of a spin density matrix. The
 command can be used globally, or as a local argument of the
 \ttt{integrate} command. For detailed information, see
 Sec.~\ref{sec:initialpolarization}. It is also possible to use
 variables as placeholders in the specifiers. Note that polarization is
 assumed to be complete, for partial polarization use ($\to$)
 \ttt{beams\_pol\_fraction}. (cf. also \ttt{beams}, \ttt{beams\_theta},
 \ttt{beams\_phi}, \ttt{beams\_momentum}, \ttt{beams\_pol\_fraction})
 %%%%%
 \item
 \ttt{beams\_pol\_fraction} \newline
 This command allows to specify the amount of polarization when using
 polarized beams ($\to$ \ttt{beams\_pol\_density}). The syntax is:
 \ttt{beams\_pol\_fraction = {\em <frac\_1>}, {\em <frac\_2>}}. Two fractions must
 be present for scatterings, being real numbers between \ttt{0} and
 \ttt{1}. A specification with percentage is also possible,
 e.g. \ttt{beams\_pol\_fraction = 80\%, 40\%}. (cf. also \ttt{beams},
 \ttt{beams\_theta}, \ttt{beams\_phi}, \ttt{beams\_momentum},
 \ttt{beams\_pol\_density})
 %%%%%
 \item
 \ttt{beams\_theta} \newline
 Command to set a crossing angle (with respect to the $z$ axis) for one
 or both of the beams of a
 scattering process: \ttt{beams\_theta = {\em <angle1>}, {\em <angle2>}} to allow
 for asymmetric beam setups (e.g. \ttt{beams\_angle = 0, 10
 degree}). Two arguments must be present for a scattering process, but
 the command can be used with one argument to integrate and simulate a
 decay of a moving particle. (cf. also \ttt{beams}, \ttt{beams\_phi},
 \ttt{beams\_momentum}, \ttt{beams\_pol\_density},
 \ttt{beams\_pol\_fraction})
 %%%%%
 \item
 \ttt{by} \newline
 Constructor that replaces the default sorting criterion (according to
 PDG codes) of the ($\to$) \ttt{sort} function on particle
 lists/subevents by one given by a unary or binary particle observable:
 \ttt{sort by {\em <observable>} [{\em <particles>} [, {\em
 <ref\_particles>}] ]}. (cf. also \ttt{sort}, \ttt{extract}, \ttt{join},
 \ttt{collect}, \ttt{combine}, \ttt{+})
 %%%%%
 \item
 \ttt{ceiling} \newline
 This is a function \ttt{ceiling ({\em <num\_val>})} that gives the
 least integer greater than or equal to \ttt{{\em <num\_val>}},
 e.g. \ttt{int i = ceiling (4.56789)} gives \ttt{i = 5}. (cf. also
 \ttt{int}, \ttt{nint}, \ttt{floor})
 %%%%%
 \item
 \ttt{circe1} \newline
 Beam structure specifier for the \circeone\ structure function for
 beamstrahlung at a linear lepton collider: \ttt{beams = e1, E1 =>
 circe1}. Note that this is a pair spectrum, so the specifier acts for
 both beams simultaneously. (cf. also \ttt{beams}, \ttt{?circe1\_photons},
 \ttt{?circe1\_photon2}, \ttt{circe1\_sqrts},
 \ttt{?circe1\_generate}, \ttt{?circe1\_map},
 \ttt{circe1\_eps}, \newline \ttt{circe1\_mapping\_slope}, \ttt{circe1\_ver},
 \ttt{circe1\_rev}, \ttt{\$circe1\_acc}, \ttt{circe1\_chat})
 %%%%%
 \item
 \ttt{circe2} \newline
 Beam structure specifier for the lepton-collider structure function
 for photon spectra, \circetwo: \ttt{beams = A, A => circe2}. Note that
 this is a pair spectrum, an application to only one beam is not
 possible. (cf. also \ttt{beams}, \ttt{?circe2\_polarized},
 \ttt{\$circe2\_file}, \ttt{\$circe2\_design})
 %%%%%
 \item
 \ttt{clear} \newline
 This command allows to clear a variable set before: \ttt{clear
 ({\em <clearable var.>})} resets the variable \ttt{{\em <clearable var.>}} which
 could be the \ttt{beams}, the \ttt{unstable} settings, \ttt{sqrts},
 any kind of \ttt{cuts} or \ttt{scale} expressions, any user-set
 variable etc. The syntax of the command is completely analogous to
 ($\to$) \ttt{show}.
 %%%%%
 \item
 \ttt{close\_out} \newline
 With the command, \ttt{close\_out ("{\em <out\_file">})} user-defined
 information like data or ($\to$) \ttt{printf} statements can be
 written out to a user-defined file. The command closes an I/O stream to
 an external file \ttt{{\em <out\_file>}}. (cf. also \ttt{open\_out},
 \ttt{\$out\_file}, \ttt{printf})
 %%%%%
 \item
 \ttt{cluster} \newline
 Command that allows to cluster all particles in a subevent to a set of
 jets: \ttt{cluster [{\em<particles>}]}. It also to cluster particles
 subject to a certain boolean condition, \ttt{cluster if
   {\em<condition>} [{\em<particles>}]}. At the moment only available
 if the \fastjet\ package is linked.
 (cf. also \ttt{jet\_r}, \ttt{combine}, \ttt{jet\_algorithm},
 \ttt{kt\_algorithm}, \newline \ttt{cambridge\_[for\_passive\_]algorithm},
 \ttt{antikt\_algorithm}, \ttt{plugin\_algorithm}, \newline
 \ttt{genkt\_[for\_passive\_]algorithm},
 \ttt{ee\_kt\_algorithm}, \ttt{ee\_genkt\_algorithm},
 \ttt{?keep\_flavors\_when\_clustering})
 %%%%%
 \item
 \ttt{collect} \newline
 The \ttt{collect [{\em <list>}]} operation collects all particles in
 the list \ttt{{\em <list>}} into a one-entry subevent with a
 four-momentum of the sum of all four-momenta of non-overlapping
 particles in \ttt{{\em <list>}}. (cf. also \ttt{combine},
 \ttt{select}, \ttt{extract}, \ttt{sort})
 %%%%%
 \item
 \ttt{complex} \newline
 Defines a complex variable. The syntax is e.g. \ttt{complex x = 2 + 3
   * I}. (cf.~also \ttt{int}, \ttt{real})
 %%%%%
 \item
 \ttt{combine} \newline
 The \ttt{combine [{\em <list1>}, {\em <list2>}]} operation makes a particle list
 whose entries are the result of adding (the momenta of) each pair of
 particles in the two input lists \ttt{list1}, {list2}. For example,
 \ttt{combine [incoming lepton, lepton]} constructs all mutual pairings
 of an incoming lepton with an outgoing lepton (an alias for the
 leptons has to be defined, of course). (cf. also \ttt{collect},
 \ttt{select}, \ttt{extract}, \ttt{sort}, \ttt{+})
 %%%%%
 \item
 \ttt{compile} \newline
 The \ttt{compile ()} command has no arguments (the parentheses can
 also been left out: /\ttt{compile ()}. The command is optional, it
 invokes the compilation of the process(es) (i.e. the matrix element
 file(s)) to be compiled as a shared library. This shared object file
 has the standard name \ttt{default\_lib.so} and resides in the
 \ttt{.libs} subdirectory of the corresponding user workspace. If the
 user has defined a different library name \ttt{lib\_name} with the
 \ttt{library} command, then WHIZARD compiles this as the shared object
 \ttt{.libs/lib\_name.so}. (This allows to split process classes and to
 avoid too large libraries.)
 Another possibility is to use the command \ttt{compile as
   "static\_name"}. This will compile and link the process library in a
 static way and create the static executable \ttt{static\_name} in the
 user workspace. (cf. also \ttt{library})
 %%%%%
 \item
 \ttt{compile\_analysis} \newline
 The \ttt{compile\_analysis} statement does the same as
 the \ttt{write\_analysis} command, namely to tell \whizard\ to write
 the analysis setup by the user for the \sindarin\ input file under
 consideration. If no \ttt{\$out\_file} is provided, the histogram
 tables/plot data etc. are written to the default file
 \ttt{whizard\_analysis.dat}. In addition to \ttt{write\_analysis},
 \ttt{compile\_analysis} also invokes the \whizard\ \LaTeX routines for
 producing postscript or PDF output of the data (unless the flag
 $\rightarrow$ \ttt{?analysis\_file\_only} is set to \ttt{true}).
 (cf. also \ttt{\$out\_file}, \ttt{write\_analysis},
 \ttt{?analysis\_file\_only})
 %%%%%
 \item
 \ttt{conjg} \newline
 Numerical function that takes the complex conjugate of its argument:
 \ttt{conjg ({\em <num\_val>})} yields \ttt{{\em
 <num\_val>}$^\ast$}. (cf. also \ttt{abs}, \ttt{sgn}, \ttt{mod}, \ttt{modulo})
 %%%%%
 \item
 \ttt{cos} \newline
 Numerical function \ttt{cos ({\em <num\_val>})} that calculates the
 cosine trigonometric function of real and complex numerical numbers or
 variables. (cf. also \ttt{sin}, \ttt{tan}, \ttt{asin}, \ttt{acos},
 \ttt{atan})
 %%%%%
 \item
 \ttt{cosh} \newline
 Numerical function \ttt{cosh ({\em <num\_val>})} that calculates the
 hyperbolic cosine function of real and complex numerical numbers or
 variables. Note that its inverse function is part of the
 \ttt{Fortran2008} status and hence not realized. (cf. also \ttt{sinh},
 \ttt{tanh})
 %%%%%
 \item
 \ttt{count} \newline
 Subevent function that counts the number of particles or particle
 pairs in a subevent: \ttt{count [{\em <particles\_1>} [, {\em
 <particles\_2>}]]}. This can also be a counting subject to a
 condition: \ttt{count if {\em <condition>} [{\em <particles\_1>} [,
 {\em <particles\_2>}]]}.
 %%%%%
 \item
 \ttt{cuts} \newline
 This command defines the cuts to be applied to certain processes. The
 syntax is: \ttt{cuts = {\em <log\_class>} {\em <log\_expr>} [{\em <unary or binary
   particle (list) arg>}]}, where the cut expression must be initialized
 with a logical classifier \ttt{log\_class} like \ttt{all}, \ttt{any},
 \ttt{no}. The logical expression \ttt{log\_expr} contains the cut to
 be evaluated. Note that this need not only be a kinematical cut
 expression like \ttt{E > 10  GeV} or \ttt{5 degree < Theta < 175
   degree}, but can also be some sort of trigger expression or event
 selection, e.g. \ttt{PDG == 15} would select a tau lepton.  Whether the
 expression is evaluated on particles or pairs of particles depends on
 whether the discriminating variable is unary or binary, \ttt{Dist}
 being obviously binary, \ttt{Pt} being unary. Note that some variables
 are both unary and binary, e.g. the invariant mass $M$. Cut
 expressions can be connected by the logical  connectives \ttt{and} and
 \ttt{or}. The \ttt{cuts} statement acts on all subsequent process
 integrations and analyses until a new \ttt{cuts} statement appears.
 (cf. also \ttt{all}, \ttt{any},
 \ttt{Dist}, \ttt{E}, \ttt{M},
 \ttt{no}, \ttt{Pt}).
 %%%%%
 \item
 \ttt{debug} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of the very verbose \whizard\ ASCII event
 file format intended for debugging. (cf. also \ttt{\$sample},
 \ttt{sample\_format}, \ttt{\$sample\_normalization})
 %%%%%
 \item
 \ttt{degree} \newline
 Expression specifying the physical unit of degree for angular
 variables, e.g. the cut expression function \ttt{Theta}. (if no unit is
 specified for angular variables, radians are used; cf. \ttt{rad}, \ttt{mrad}).
 %%%%
 \item
 \ttt{Dist} \newline
 Binary observable specifier, that gives the $\eta$-$\phi$-
 (pseudorapidity-azimuth) distance $R = \sqrt{(\Delta \eta)^2 +
 (\Delta\phi)^2}$ between the momenta of the two particles: \ttt{eval
 Dist [jet, jet]}. (cf. also \ttt{eval}, \ttt{cuts}, \ttt{selection},
 \ttt{Theta}, \ttt{Eta}, \ttt{Phi})
 %%%%%
 \item
 \ttt{dump} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of the intrinsic \whizard\ event record format
 (output of the \ttt{particle\_t} type container). (cf. also
 \ttt{\$sample}, \ttt{sample\_format}, \ttt{\$sample\_normalization}
 %%%%%
 \item
 \ttt{E} \newline
 Unary (binary) observable specifier for the energy of a single
 (two) particle(s), e.g. \ttt{eval E ["W+"]}, \ttt{all E > 200 GeV [b,
   B]}. (cf. \ttt{eval}, \ttt{cuts}, \ttt{selection})
 %%%%%
 \item
 \ttt{else} \label{sindarin_else}\newline
 Constructor for providing an alternative in a conditional clause:
 \ttt{if {\em <log\_expr>} then {\em <expr 1>} else {\em <expr 2>} endif}. (cf. also
 \ttt{if}, \ttt{elsif}, \ttt{endif}, \ttt{then}).
 %%%%%
 \item
 \ttt{elsif} \newline
 Constructor for concatenating more than one conditional clause with
 each other: \ttt{if {\em <log\_expr 1>} then {\em <expr 1>} elsif {\em <log\_expr 2>}
 then {\em <expr 2>} \ldots endif}. (cf. also \ttt{if}, \ttt{else},
 \ttt{endif}, \ttt{then}).
 %%%%%
 \item
 \ttt{endif} \newline
 Mandatory constructor to conclude a conditional clause: \ttt{if
   {\em <log\_expr>} then \ldots endif}. (cf. also \ttt{if},
 \ttt{else}, \ttt{elsif}, \ttt{then}).
 %%%%%
 \item
 \ttt{energy\_scan} \newline
 Beam structure specifier for the energy scan structure function:
 \ttt{beams = e1, E1 => energy\_scan}. This pair spectrum that has to
 be applied to both beams simultaneously can be used to scan over a
 range of collider energies without using the \ttt{scan} command.
 (cf. also \ttt{beams}, \ttt{scan}, \ttt{?energy\_scan\_normalize})
 %%%%%
 \item
 \ttt{epa} \newline
 Beam structure specifier for the equivalent-photon approximation
 (EPA), i.e the Weizs\"acker-Williams structure function:
 e.g. \ttt{beams = e1, E1 => epa} (applied to both beams), or
 e.g. \ttt{beams = e1, u => epa, none} (applied to only one
 beam). (cf. also \ttt{beams}, \ttt{epa\_alpha}, \ttt{epa\_x\_min},
 \ttt{epa\_mass}, \ttt{epa\_q\_max}, \ttt{epa\_q\_min},
 \ttt{?epa\_recoil}, \ttt{?epa\_keep\_energy})
 %%%%%
 \item
 \ttt{Eta} \newline
 Unary and also binary observable specifier, that as a unary observable
 gives the pseudorapidity of a particle momentum. The pseudorapidity is
 given by $\eta = - \log \left[ \tan (\theta/2) \right]$, where
 $\theta$ is the angle with the beam direction. As a binary
 observable, it gives the pseudorapidity difference between the momenta
 of two particles, where $\theta$ is the enclosed angle: \ttt{eval Eta
 [e1]},  \ttt{all abs (Eta) < 3.5 [jet, jet]}. (cf. also \ttt{eval},
 \ttt{cuts}, \ttt{selection}, \ttt{Rap}, \ttt{abs})
 %%%%%
 \item
 \ttt{eV} \newline
 Physical unit, stating that the corresponding number is in electron
 volt. (cf. also \ttt{keV}, \ttt{meV}, \ttt{MeV}, \ttt{GeV}, \ttt{TeV})
 %%%%%
 \item
 \ttt{eval} \newline
 Evaluator that tells \whizard\ to evaluate the following expr:
 \ttt{eval {\em <expr>}}. Examples are: \ttt{eval Rap [e1]}, \ttt{eval
   M / 1 GeV [combine [q,Q]]} etc. (cf. also \ttt{cuts},
 \ttt{selection}, \ttt{record})
 %%%%%
 \item
 \ttt{ewa} \newline
 Beam structure specifier for the equivalent-photon approximation
 (EWA): e.g. \ttt{beams = e1, E1 => ewa} (applied to both beams), or
 e.g. \ttt{beams = e1, u => ewa, none} (applied to only one
 beam). (cf. also \ttt{beams}, \ttt{ewa\_x\_min}, \ttt{ewa\_pt\_max},
 \ttt{ewa\_mass}, \ttt{?ewa\_keep\_energy},
 \ttt{?ewa\_recoil})
 %%%%%
 \item
 \ttt{exec} \newline
 Constructor \ttt{exec ("{\em <cmd\_name>}")} that demands WHIZARD to
 execute/run the command \ttt{cmd\_name}. For this to work that
 specific command must be present either in the path of the operating
 system or as a command in the user workspace.
 %%%%%
 \item
 \ttt{exit} \newline
 Command to finish the \whizard\ run (and not execute any further code
 beyond the appearance of \ttt{exit} in the \sindarin\ file. The command
 (which is the same as $\to$ \ttt{quit}) allows for an argument,
 \ttt{exit ({\em <expr>})}, where the expression can be executed, e.g. a
 screen message or an exit code.
 %%%%%
 \item
 \ttt{exp} \newline
 Numerical function \ttt{exp ({\em <num\_val>})} that calculates the
 exponential of real and complex numerical numbers or
 variables. (cf. also \ttt{sqrt}, \ttt{log}, \ttt{log10})
 %%%%%
 \item
 \ttt{expect} \newline
 The binary function \ttt{expect} compares two numerical expressions
 whether they fulfill a certain ordering condition or are equal up
 to a specific uncertainty or tolerance which can bet set by the
 specifier \ttt{tolerance}, i.e. in principle it checks whether a
 logical expression is true. The \ttt{expect} function does actually
 not just check a value for correctness, but also records its result.
 If failures are present when the program terminates, the exit code is
 nonzero. The syntax is  \ttt{expect ({\em <num1>} {\em
 <log\_comp>} {\em <num2>})}, where \ttt{{\em <num1>}} and
 \ttt{{\em <num2>}} are two numerical values (or
 corresponding variables) and  \ttt{{\em <log\_comp>}} is one of the following
 logical comparators: \ttt{<}, \ttt{>}, \ttt{<=},  \ttt{>=}, \ttt{==},
 \ttt{<>}.
 (cf. also \ttt{<}, \ttt{>}, \ttt{<=},  \ttt{>=}, \ttt{==}, \ttt{<>},
 \ttt{tolerance}).
 %%%%%
 \item
 \ttt{extract} \newline
 Subevent function that either extracts the first element of a
 particle list/subevent: \ttt{extract [ {\em <particles>}]}, or the
 element at position \ttt{<index\_value>} of the particle list:
 \ttt{extract {\em index <index\_value>} [ {\em
     <particles>}]}. Negative index values count from the end of the
 list. (cf. also \ttt{sort}, \ttt{combine},
 \ttt{collect}, \ttt{+}, \ttt{index})
 %%%%%
 \item
 \ttt{factorization\_scale} \newline
 This is a command, \ttt{factorization\_scale = {\em <expr>}}, that sets
 the factorization scale of a process or list of processes. It
 overwrites a possible scale set by the ($\to$) \ttt{scale} command.
 \ttt{{\em <expr>}} can be any kinematic expression that leads to a result of
 momentum dimension one, e.g. \ttt{100 GeV}, \ttt{eval
 Pt [e1]}. (cf. also \ttt{renormalization\_scale}).
 %%%%%
 \item
 \ttt{false} \newline
 Constructor stating that a logical expression or variable is false,
 e.g. \ttt{?{\em <log\_var>} = false}. (cf. also \ttt{true}).
 %%%%%
 \item
 \ttt{fbarn} \newline
 Physical unit, stating that a number is in femtobarns ($10^{-15}$
 barn). (cf. also \ttt{nbarn}, \ttt{abarn}, \ttt{pbarn})
 %%%%%
 \item
 \ttt{floor} \newline
 This is a function \ttt{floor ({\em <num\_val>})} that gives the
 greatest integer less than or equal to \ttt{{\em <num\_val>}},
 e.g. \ttt{int i = floor (4.56789)} gives \ttt{i = 4}. (cf. also
 \ttt{int}, \ttt{nint}, \ttt{ceiling})
 %%%%%
 \item
 \ttt{gaussian} \newline
 Beam structure specifier that imposes a Gaussian energy distribution,
 separately for each beam.  The $\sigma$ values are set by
 \ttt{gaussian\_spread1} and \ttt{gaussian\_spread2}, respectively.
 %%%%%
 \item
 \ttt{GeV} \newline
 Physical unit, energies in $10^9$ electron volt. This is the default
 energy unit of WHIZARD. (cf. also \ttt{eV}, \ttt{keV}, \ttt{MeV}, \ttt{meV},
 \ttt{TeV})
 %%%%%
 \item
 \ttt{graph} \newline
 This command defines the necessary information regarding producing
 a graph of a function in \whizard's internal graphical \gamelan\
 output. The syntax is: \ttt{graph {\em <record\_name>} \{ {\em <optional
 arguments>} \}}. The record with name \ttt{{\em <record\_name>}} has to be
 defined, either before or after the graph definition. Possible optional
 arguments of the \ttt{graph} command are the minimal and maximal values
 of the axes (\ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}).
 (cf. \ttt{plot}, \ttt{histogram}, \ttt{record})
 %%%%%
 \item
 \ttt{Hel} \newline
 Unary observable specifier that allows to specify the helicity of a
 particle, e.g. \ttt{all Hel == -1 [e1]} in a selection. (cf. also
 \ttt{eval}, \ttt{cuts}, \ttt{selection})
 %%%%%
 \item
 \ttt{hepevt} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of HEPEVT ASCII event files. (cf. also \ttt{\$sample},
 \ttt{sample\_format})
 %%%%%
 \item
 \ttt{hepevt\_verb} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of the extended or verbose version of HEPEVT ASCII event
 files. (cf. also \ttt{\$sample}, \ttt{sample\_format})
 %%%%%
 \item
 \ttt{hepmc} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of HepMC ASCII event files. Note that this is only
 available if the HepMC package is installed and correctly
 linked. (cf. also \ttt{\$sample}, \ttt{sample\_format},
 \ttt{?hepmc\_output\_cross\_section})
 %%%%%
 \item
 \ttt{histogram} \newline
 This command defines the necessary information regarding plotting data
 as a histogram, in the form of: \ttt{histogram {\em <record\_name>} \{
 {\em <optional arguments>} \}}. The record with name \ttt{{\em <record\_name>}} has to be
 defined, either before or after the histogram definition. Possible optional
 arguments of the \ttt{histogram} command are the minimal and maximal values
 of the axes (\ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}).
 (cf. \ttt{graph}, \ttt{plot}, \ttt{record})
 %%%%%
 \item
 \ttt{if} \newline
 Conditional clause with the construction \ttt{if {\em <log\_expr>} then
 {\em <expr>} [else {\em <expr>} \ldots] endif}. Note that there must be an
 \ttt{endif}  statement. For more complicated expressions it is better
 to use expressions in parentheses: \ttt{if ({\em <log\_expr>}) then
 \{{\em <expr>}\} else \{{\em <expr>}\} endif}. Examples are a selection of up quarks
 over down quarks depending on a logical variable: \ttt{if ?ok then u
   else d}, or the setting of an integer variable depending on the
 rapidity of some particle: \ttt{if (eta > 0) then \{ a = +1\} else
 \{ a = -1\}}. (cf. also \ttt{elsif}, \ttt{endif}, \ttt{then})
 %%%%%
 \item
 \ttt{in} \newline
 Second part of the constructor to let a variable be local to an
 expression. It has the syntax \ttt{let {\em <var>} = {\em <value>} in
 {\em <expression>}}.  E.g. \ttt{let int a = 3 in let int b = 4 in
 {\em <expression>}} (cf. also \ttt{let})
 %%%%%
 \item
 \ttt{include} \newline
 The \ttt{include} statement, \ttt{include ("file.sin")} allows to
 include external \sindarin\ files \ttt{file.sin} into the main WHIZARD
 input file. A standard example is the inclusion of the standard cut
 file \ttt{default\_cuts.sin}.
 %%%%%
 \item
 \ttt{incoming} \newline
 Constructor that specifies particles (or subevents) as incoming. It is
 used in cuts, analyses or selections, e.g. \ttt{cuts = all Theta > 20
 degree [incoming lepton, lepton]}. (cf. also \ttt{beam}, \ttt{outgoing}, 
 \ttt{cuts}, \ttt{analysis}, \ttt{selection}, \ttt{record})
 %%%%%
 \item
 \ttt{index} \newline
 Specifies the position of the element of a particle to be extracted by
 the subevent function ($\to$) \ttt{extract}: \ttt{extract {\em index
 <index\_value>} [ {\em <particles>}]}. Negative index values count
 from the end of the list. (cf. also \ttt{extract}, \ttt{sort}, \ttt{combine},
 \ttt{collect}, \ttt{+})
 %%%%%
 \item
 \ttt{int} \newline
 1) This is a constructor to specify integer constants in the input
 file. Strictly speaking, it is a unary function setting the value
 \ttt{int\_val} of the integer variable \ttt{int\_var}:
 \ttt{int {\em <int\_var>} = {\em <int\_val>}}. Note that is mandatory for all
 user-defined variables. (cf. also \ttt{real} and \ttt{complex})
 2) It is a function \ttt{int ({\em <num\_val>})} that converts real and
 complex numbers (here their real parts) into integers. (cf. also
 \ttt{nint}, \ttt{floor}, \ttt{ceiling})
 %%%%%
 \item
 \ttt{integrate} \newline
 The \ttt{integrate ({\em <proc\_name>}) \{ {\em <integrate\_options>} \}} command
 invokes the integration (phase-space generation and Monte-Carlo
 sampling) of the process \ttt{proc\_name} (which can also be a list of
 processes) with the integration options
 \ttt{{\em <integrate\_options>}}. Possible options are (1) via
 \ttt{\$integration\_method = "{\em <intg. method>}"} the integration
 method (the default being VAMP), (2) the number of iterations and
 calls per integration during the Monte-Carlo phase-space integration
 via the \ttt{iterations} specifier; (3) goal for the
 accuracy, error or relative error (\ttt{accuracy\_goal},
 \ttt{error\_goal}, \ttt{relative\_error\_goal}). (4) Invoking only
 phase space generation (\ttt{?phs\_only = true}), (5) making test
 calls of the matrix element. (cf. also \ttt{iterations},
 \ttt{accuracy\_goal}, \ttt{error\_goal}, \ttt{relative\_error\_goal},
 \ttt{error\_threshold})
 %%%%%
 \item
 \ttt{isr} \newline
 Beam structure specifier for the lepton-collider/QED initial-state
 radiation (ISR) structure function: e.g. \ttt{beams = e1, E1 => isr}
 (applied to both beams), or e.g. \ttt{beams = e1, u => isr, none}
 (applied to only one beam). (cf. also \ttt{beams}, \ttt{isr\_alpha},
 \ttt{isr\_q\_max}, \ttt{isr\_mass}, \ttt{isr\_order},
 \ttt{?isr\_recoil}, \ttt{?isr\_keep\_energy})
 %%%%%
 \item
 \ttt{iterations} \qquad (default: internal heuristics) \newline
 Option to set the number of iterations and calls per iteration during
 the Monte-Carlo phase-space integration process. The syntax is
 \ttt{iterations = {\em <n\_iterations>}:{\em <n\_calls>}}. Note that this can be
 also a list, separated by colons, which breaks up the integration
 process into passes of the specified number of integrations and calls
 each. It works for all integration methods. For VAMP, there is the
 additional option to specify whether grids and channel weights should
 be adapted during iterations (\ttt{"g"}, \ttt{"w"},
 \ttt{"gw"} for both, or \ttt{""} for no adaptation).   (cf. also
 \ttt{integrate}, \ttt{accuracy\_goal}, \ttt{error\_goal},
 \ttt{relative\_error\_goal}, \ttt{error\_threshold}).
 %%%%%
 \item
 \ttt{join} \newline
 Subevent function that concatenates two particle lists/subevents if
 there is no overlap: \ttt{join [{\em <particles>}, {\em
 <new\_particles>}]}. The joining of the two lists can also be made
 depending on a condition: \ttt{join if {\em <condition>} [{\em
 <particles>}, {\em <new\_particles>}]}. (cf. also \ttt{\&},
 \ttt{collect}, \ttt{combine}, \ttt{extract}, \ttt{sort}, \ttt{+})
 %%%%%
 \item
 \ttt{keV} \newline
 Physical unit, energies in $10^3$ electron volt. (cf. also \ttt{eV},
 \ttt{meV}, \ttt{MeV}, \ttt{GeV}, \ttt{TeV})
 %%%%%
 \item
 \ttt{kT} \newline
 Binary particle observable that represents a jet $k_T$ clustering
 measure: \ttt{kT [j1, j2]} gives the following kinematic expression:
 $2 \min(E_{j1}^2, E_{j2}^2) / Q^2 \times (1 - \cos\theta_{j1,j2})$. At the
 moment, $Q^2 = 1$.
 %%%%%
 \item
 \ttt{let} \newline
 This allows to let a variable be local to an expression. It has the
 syntax \ttt{let {\em <var>} = {\em <value>} in {\em <expression>}}.
 E.g. \ttt{let int a = 3 in let int b = 4 in {\em <expression>}}
 (cf. also \ttt{in})
 %%%%%
 \item
 \ttt{lha} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of the \whizard\ version 1 style (deprecated) LHA ASCII event
 format files. (cf. also \ttt{\$sample}, \newline
 \ttt{sample\_format})
 %%%%%
 \item
 \ttt{lhapdf} \newline
 This is a beams specifier to demand calling \lhapdf\ parton densities as
 structure functions to integrate processes in hadron collisions. Note
 that this only works if the external \lhapdf\ library is present and
 correctly linked. (cf. \ttt{beams}, \ttt{\$lhapdf\_dir},
 \ttt{\$lhapdf\_file}, \ttt{lhapdf\_photon},
 \ttt{\$lhapdf\_photon\_file}, \ttt{lhapdf\_member},
 \ttt{lhapdf\_photon\_scheme})
 %%%%%
 \item
 \ttt{lhapdf\_photon} \newline
 This is a beams specifier to demand calling \lhapdf\ parton densities as
 structure functions to integrate processes in hadron collisions with a
 photon as initializer of the hard scattering process. Note
 that this only works if the external \lhapdf\ library is present and
 correctly linked. (cf. \ttt{beams}, \ttt{lhapdf}, \ttt{\$lhapdf\_dir},
 \ttt{\$lhapdf\_file}, \ttt{\$lhapdf\_photon\_file},
 \ttt{lhapdf\_member}, \ttt{lhapdf\_photon\_scheme})
 %%%%%
 \item
 \ttt{lhef} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of the Les Houches Accord (LHEF) event format files, with
 XML headers. There are several different versions of this format,
 which can be selected via the \ttt{\$lhef\_version} specifier
 (cf. also \ttt{\$sample}, \ttt{sample\_format}, \ttt{\$lhef\_version},
 \ttt{\$lhef\_extension}, \ttt{?lhef\_write\_sqme\_prc},
 \newline \ttt{?lhef\_write\_sqme\_ref}, \ttt{?lhef\_write\_sqme\_alt})
 %%%%%
 \item
 \ttt{library} \newline
 The command \ttt{library = "{\em <lib\_name>}"} allows to specify a separate
 shared object library archive \ttt{lib\_name.so}, not using the
 standard library \ttt{default\_lib.so}. Those libraries (when using
 shared libraries) are located in the \ttt{.libs} subdirectory of the
 user workspace. Specifying a separate library is useful for splitting
 up large lists of processes, or to restrict a larger number of
 different loaded model files to one specific process library.
 (cf. also \ttt{compile}, \ttt{\$library\_name})
 %%%%%
 \item
 \ttt{log} \newline
 Numerical function \ttt{log ({\em <num\_val>})} that calculates the
 natural logarithm of real and complex numerical numbers or
 variables. (cf. also \ttt{sqrt}, \ttt{exp}, \ttt{log10})
 %%%%%
 \item
 \ttt{log10} \newline
 Numerical function \ttt{log10 ({\em <num\_val>})} that calculates the
 base 10 logarithm of real and complex numerical numbers or
 variables. (cf. also \ttt{sqrt}, \ttt{exp}, \ttt{log})
 %%%%%
 \item
 \ttt{long} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of the long variant of HEPEVT ASCII event
 files. (cf. also \ttt{\$sample},
 \ttt{sample\_format})
 %%%%%
 \item
 \ttt{M} \newline
 Unary (binary) observable specifier for the (signed) mass of a single
 (two) particle(s), e.g. \ttt{eval M [e1]}, \ttt{any M = 91 GeV [e2,
   E2]}. (cf. \ttt{eval}, \ttt{cuts}, \ttt{selection})
 %%%%%
 \item
 \ttt{M2} \newline
 Unary (binary) observable specifier for the mass squared of a single
 (two) particle(s), e.g. \ttt{eval M2 [e1]}, \ttt{all M2 > 2*mZ [e2,
   E2]}. (cf. \ttt{eval}, \ttt{cuts}, \ttt{selection})
 %%%%%
 \item
 \ttt{max} \newline
 Numerical function with two arguments \ttt{max ({\em <var1>}, {\em
 <var2>})} that gives the maximum of the two arguments: $\max (var1,
 var2)$. It can act on all combinations of integer and real
 variables. Example: \ttt{real heavier\_mass = max (mZ, mH)}. (cf. also
 \ttt{min})
 %%%%%
 \item
 \ttt{meV} \newline
 Physical unit, stating that the corresponding number is in $10^{-3}$
 electron volt. (cf. also \ttt{eV}, \ttt{keV}, \ttt{MeV}, \ttt{GeV},
 \ttt{TeV})
 %%%%%
 \item
 \ttt{MeV} \newline
 Physical unit, energies in $10^6$ electron volt. (cf. also \ttt{eV},
 \ttt{keV}, \ttt{meV}, \ttt{GeV}, \ttt{TeV})
 %%%%%
 \item
 \ttt{min} \newline
 Numerical function with two arguments \ttt{min ({\em <var1>}, {\em
 <var2>})} that gives the minimum of the two arguments: $\min (var1,
 var2)$. It can act on all combinations of integer and real
 variables. Example: \ttt{real lighter\_mass = min (mZ, mH)}. (cf. also
 \ttt{max})
 %%%%%
 \item
 \ttt{mod} \newline
 Numerical function for integer and real numbers \ttt{mod (x, y)} that
 computes the remainder of the division of \ttt{x} by \ttt{y} (which
 must not be zero). (cf. also
 \ttt{abs}, \ttt{conjg}, \ttt{sgn}, \ttt{modulo})
 %%%%%
 \item
 \ttt{model} \qquad (default: \ttt{SM}) \newline
 With this specifier, \ttt{model = {\em <model\_name>}}, one sets the hard
 interaction physics model for the processes defined after this model
 specification. The list of available models can be found in Table
 \ref{tab:models}. Note that the model specification can appear
 arbitrarily often in a \sindarin\ input file, e.g. for compiling and
 running processes defined in different physics models. (cf. also
 \ttt{\$model\_name})
 %%%%%
 \item
 \ttt{modulo} \newline
 Numerical function for integer and real numbers \ttt{modulo (x, y)} that
 computes the value of $x$ modulo $y$. (cf. also
 \ttt{abs}, \ttt{conjg}, \ttt{sgn}, \ttt{mod})
 %%%%%
 \item
 \ttt{mokka} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of the MOKKA variant for HEPEVT ASCII event
 files. (cf. also \ttt{\$sample},
 \ttt{sample\_format})
 %%%%%
 \item
 \ttt{mrad} \newline
 Expression specifying the physical unit of milliradians for angular
 variables. This default in \whizard\ is \ttt{rad}. (cf. \ttt{degree}, \ttt{rad}).
 %%%%%
 \item
 \ttt{nbarn} \newline
 Physical unit, stating that a number is in nanobarns ($10^{-9}$
 barn). (cf. also \ttt{abarn}, \ttt{fbarn}, \ttt{pbarn})
 %%%%%
 \item
 \ttt{n\_in} \newline
 Integer variable that accesses the number of incoming particles of a
 process. It can be used in cuts or in an analysis. (cf. also
 \ttt{sqrts\_hat}, \ttt{cuts}, \ttt{record}, \ttt{n\_out}, \ttt{n\_tot})
 %%%%%
 \item
+\ttt{Nacl} \newline
+Unary observable specifier that returns the total number of open anticolor lines
+of a particle or subevent (i.e., composite particle).  Defined only if
+\ttt{?colorize\_subevt} is true.. (cf. also
+\ttt{Ncol}, \ttt{?colorize\_subevt})
+%%%%%
+\item
+\ttt{Ncol} \newline
+Unary observable specifier that returns the total number of open color lines
+of a particle or subevent (i.e., composite particle).  Defined only if
+\ttt{?colorize\_subevt} is true.. (cf. also
+\ttt{Nacl}, \ttt{?colorize\_subevt})
+%%%%%
+\item
 \ttt{nint} \newline
 This is a function \ttt{nint ({\em <num\_val>})} that converts real
 numbers into the closest integer, e.g. \ttt{int i = nint (4.56789)}
 gives \ttt{i = 5}. (cf. also
 \ttt{int}, \ttt{floor}, \ttt{ceiling})
 %%%%%
 \item
 \ttt{no} \newline
 \ttt{no} is a function that works on a logical expression and a list,
 \ttt{no {\em <log\_expr>} [{\em <list>}]}, and returns \ttt{true} if and only if
 \ttt{log\_expr} is fulfilled for {\em none} of the entries in
 \ttt{list}, and \ttt{false} otherwise. Examples: \ttt{no Pt < 100 GeV
   [lepton]} checks whether no lepton is softer than 100 GeV. It is the
 logical opposite of the function \ttt{all}. Logical expressions with
 \ttt{no} can be logically combined with \ttt{and} and
 \ttt{or}. (cf. also \ttt{all}, \ttt{any}, \ttt{and}, and \ttt{or})
 %%%%%
 \item
 \ttt{none} \newline
 Beams specifier that can used to explicitly {\em not} apply a
 structure function to a beam, e.g. in HERA physics: \ttt{beams = e1, P
   => none, pdf\_builtin}. (cf. also \ttt{beams})
 %%%%%
 \item
 \ttt{not} \newline
 This is the standard logical negation that converts true into false
 and vice versa. It is applied to logical values, e.g. cut
 expressions. (cf. also \ttt{and}, \ttt{or}).
 %%%%%
 \item
 \ttt{n\_out} \newline
 Integer variable that accesses the number of outgoing particles of a
 process. It can be used in cuts or in an analysis. (cf. also
 \ttt{sqrts\_hat}, \ttt{cuts}, \ttt{record}, \ttt{n\_in}, \ttt{n\_tot})
 %%%%%
 \item
 \ttt{n\_tot} \newline
 Integer variable that accesses the total number of particles (incoming
 plus outgoing) of a process. It can be used in cuts or in an
 analysis. (cf. also \ttt{sqrts\_hat}, \ttt{cuts}, \ttt{record},
 \ttt{n\_in}, \ttt{n\_out})
 %%%%%
 \item
 \ttt{observable} \newline
 With this, \ttt{observable = {\em <obs\_spec>}}, the user is able to define
 a variable specifier \ttt{obs\_spec} for observables. These can be
 reused in the analysis, e.g. as a \ttt{record}, as functions of the
 fundamental kinematical variables of the processes.
 (cf. \ttt{analysis}, \ttt{record})
 %%%%%
 \item
 \ttt{open\_out} \newline
 With the command, \ttt{open\_out ("{\em <out\_file">})} user-defined
 information like data or ($\to$) \ttt{printf} statements can be
 written out to a user-defined file. The command opens an I/O stream to
 an external file \ttt{{\em <out\_file>}}. (cf. also \ttt{close\_out},
 \ttt{\$out\_file}, \ttt{printf})
 %%%%%
 \item
 \ttt{or} \newline
 This is the standard two-place logical connective that has the value
 true if one of its operands is true, otherwise a value of false. It
 is applied to logical values, e.g. cut expressions. (cf. also
 \ttt{and}, \ttt{not}).
 %%%%%
 \item
 \ttt{outgoing} \newline
 Constructor that specifies particles (or subevents) as outgoing. It is
 used in cuts, analyses or selections, e.g. \ttt{cuts = all Theta > 20
 degree [incoming lepton, outgoing lepton]}. Note that the \ttt{outgoing}
 keyword is redundant and included only for completeness: \ttt{outgoing lepton}
 has the same meaning as \ttt{lepton}.  (cf. also \ttt{beam},
 \ttt{incoming}, 
 \ttt{cuts}, \ttt{analysis}, \ttt{selection}, \ttt{record})
 %%%%%
 \item
 \ttt{P} \newline
 Unary (binary) observable specifier for the spatial momentum
 $\sqrt{\vec{p}^2}$ of a single (two) particle(s), e.g. \ttt{eval P
 ["W+"]}, \ttt{all P > 200 GeV [b, B]}. (cf. \ttt{eval}, \ttt{cuts},
 \ttt{selection})
 %%%%%
 \item
 \ttt{pbarn} \newline
 Physical unit, stating that a number is in picobarns ($10^{-12}$
 barn). (cf. also \ttt{abarn}, \ttt{fbarn}, \ttt{nbarn})
 %%%%%
 \item
 \ttt{pdf\_builtin} \newline
 This is a beams specifier for \whizard's internal PDF structure
 functions to integrate processes in hadron collisions.
 (cf. \ttt{beams}, \ttt{pdf\_builtin\_photon},
 \ttt{\$pdf\_builtin\_file})
 %%%%%
 \item
 \ttt{pdf\_builtin\_photon} \newline
 This is a beams specifier for \whizard's internal PDF structure
 functions to integrate processes in hadron collisions with a photon as
 initializer of the hard scattering process.
 (cf. \ttt{beams}, \ttt{\$pdf\_builtin\_file})
 %%%%%
 \item
 \ttt{PDG} \newline
 Unary observable specifier that allows to specify the PDG code of a
 particle, e.g. \ttt{eval PDG [e1]}, giving \ttt{11}. (cf. also
 \ttt{eval}, \ttt{cuts}, \ttt{selection})
 %%%%%
 \item
 \ttt{Phi} \newline
 Unary and also binary observable specifier, that as a unary observable
 gives the azimuthal angle of a particle's momentum in the detector
 frame (beam into $+z$ direction). As a binary observable, it gives the
 azimuthal difference between the momenta of two particles: \ttt{eval
 Phi [e1]},  \ttt{all Phi > Pi [jet, jet]}. (cf. also \ttt{eval},
 \ttt{cuts}, \ttt{selection}, \ttt{Theta})
 %%%%%
 \item
 \ttt{Pl} \newline
 Unary (binary) observable specifier for the longitudinal momentum
 ($p_z$ in the c.m. frame) of a single (two) particle(s),
 e.g. \ttt{eval Pl ["W+"]}, \ttt{all Pl > 200 GeV [b,
 B]}. (cf. \ttt{eval}, \ttt{cuts}, \ttt{selection})
 %%%%%
 \item
 \ttt{plot} \newline
 This command defines the necessary information regarding plotting data
 as a graph, in the form of: \ttt{plot {\em <record\_name>} \{ {\em <optional
 arguments>} \}}. The record with name \ttt{{\em <record\_name>}} has to be
 defined, either before or after the plot definition. Possible optional
 arguments of the \ttt{plot} command are the minimal and maximal values
 of the axes (\ttt{x\_min}, \ttt{x\_max}, \ttt{y\_min}, \ttt{y\_max}).
 (cf. \ttt{graph}, \ttt{histogram}, \ttt{record})
 %%%%%
 \item
 \ttt{polarized} \newline
 Constructor to instruct \whizard\ to retain polarization of the
 corresponding particles in the generated events: \ttt{polarized {\em <prt1>}
   [, {\em <prt2>} , ...]}. (cf. also \ttt{unpolarized}, \ttt{simulate},
 \ttt{?polarized\_events})
 %%%%%
 \item
 \ttt{printf} \newline
 Command that allows to print data as screen messages, into logfiles or
 into user-defined output files: \ttt{printf "{\em <string\_expr>}"}. There
 exist format specifiers, very similar to the \ttt{C} command
 \ttt{printf}, e.g. \ttt{printf "\%i" (123)}. (cf. also
 \ttt{open\_out}, \ttt{close\_out}, \ttt{\$out\_file},
 \ttt{?out\_advance}, \ttt{sprintf}, \ttt{\%d}, \ttt{\%i}, \ttt{\%e},
 \ttt{\%f}, \ttt{\%g}, \ttt{\%E}, \ttt{\%F}, \ttt{\%G}, \ttt{\%s})
 %%%%%
 \item
 \ttt{process} \newline
 Allows to set a hard interaction process, either for a decay process
 with name \ttt{{\em <decay\_proc>}} as \ttt{process {\em
 <decay\_proc>} = {\em <mother>} => {\em <daughter1>}, {\em
 <daughter2>}, ...}, or for a scattering process
 with name \ttt{{\em <scat\_proc}} as \ttt{process {\em <scat\_proc>} =
 {\em <in1>}, {\em <in2>} => {\em <out1>}, {\em <out2>}, ...}. Note
 that there can be arbitrarily many processes to be defined in a
 \sindarin\ input file. There are two options for particle/process sums: flavor sums:
 \ttt{{\em <prt1>}:{\em <prt2>}:...}, where all masses have to be identical, and
 inclusive sums, \ttt{{\em <prt1>} + {\em <prt2>} + ...}. The latter can be done on
 the level of individual particles, or sums over whole final
 states. Here, masses can differ, and terms will be translated into
 different process components. The \ttt{process} command also allows for
 optional arguments, e.g. to specify a numerical identifier
 (cf. \ttt{process\_num\_id}), the method how to generate the code for
 the matrix element(s): \ttt{\$method}, possible methods are either
 with the \oMega\ matrix element generator, using template matrix
 elements with different normalizations, or completely internal matrix
 element; for \oMega\ matrix elements there is also the possibility to
 specify possible restrictions (cf. \ttt{\$restrictions}).
 %%%%%
 \item
 \ttt{Pt} \newline
 Unary (binary) observable specifier for the transverse momentum
 ($\sqrt{p_x^2 + p_y^2}$ in the c.m. frame) of a single (two)
 particle(s), e.g. \ttt{eval Pt ["W+"]}, \ttt{all Pt > 200 GeV [b,
 B]}. (cf. \ttt{eval}, \ttt{cuts}, \ttt{selection})
 %%%%%
 \item
 \ttt{Px} \newline
 Unary (binary) observable specifier for the $x$-component of the
 momentum of a single (two) particle(s), e.g. \ttt{eval Px ["W+"]},
 \ttt{all Px > 200 GeV [b, B]}. (cf. \ttt{eval}, \ttt{cuts},
 \ttt{selection})
 %%%%%
 \item
 \ttt{Py} \newline
 Unary (binary) observable specifier for the $y$-component of the
 momentum of a single (two) particle(s), e.g. \ttt{eval Py ["W+"]},
 \ttt{all Py > 200 GeV [b, B]}. (cf. \ttt{eval}, \ttt{cuts},
 \ttt{selection})
 %%%%%
 \item
 \ttt{Pz} \newline
 Unary (binary) observable specifier for the $z$-component of the
 momentum of a single (two) particle(s), e.g. \ttt{eval Pz ["W+"]},
 \ttt{all Pz > 200 GeV [b, B]}. (cf. \ttt{eval}, \ttt{cuts},
 \ttt{selection})
 %%%%%
 \item
 \ttt{quit} \newline
 Command to finish the \whizard\ run (and not execute any further code
 beyond the appearance of \ttt{quit} in the \sindarin\ file. The command
 (which is the same as $\to$ \ttt{exit}) allows for an argument,
 \ttt{quit ({\em <expr>})}, where the expression can be executed, e.g. a
 screen message or an quit code.
 %%%%%
 \item
 \ttt{rad} \newline
 Expression specifying the physical unit of radians for angular
 variables. This is the default in \whizard. (cf. \ttt{degree}, \ttt{mrad}).
 %%%%%
 \item
 \ttt{Rap} \newline
 Unary and also binary observable specifier, that as a unary observable
 gives the rapidity of a particle momentum. The rapidity is given by $y
 = \frac12 \log \left[ (E + p_z)/(E-p_z) \right]$. As a binary
 observable, it gives the rapidity difference between the momenta of
 two particles: \ttt{eval Rap [e1]},  \ttt{all abs (Rap) < 3.5 [jet,
   jet]}. (cf. also \ttt{eval}, \ttt{cuts}, \ttt{selection}, \ttt{Eta},
 \ttt{abs})
 %%%%%
 \item
 \ttt{read\_slha} \newline
 Tells \whizard\ to read in an input file in the SUSY Les Houches accord
 (SLHA), as \ttt{read\_slha ("slha\_file.slha")}. Note that the files
 for the use in \whizard\ should have the suffix \ttt{.slha}.
 (cf. also \ttt{write\_slha}, \ttt{?slha\_read\_decays},
 \ttt{?slha\_read\_input}, \ttt{?slha\_read\_spectrum})
 %%%%%
 \item
 \ttt{real} \newline
 This is a constructor to specify real constants in the input
 file. Strictly speaking, it is a unary function setting the value
 \ttt{real\_val} of the real variable \ttt{real\_var}:
 \ttt{real {\em <real\_var>} = {\em <real\_val>}}. (cf. also \ttt{int} and
 \ttt{complex})
 %%%%%
 \item
 \ttt{real\_epsilon}\\
 Predefined real; the relative uncertainty intrinsic to the floating
 point type of the \fortran\ compiler with which \whizard\ has been
 built.
 %%%%%
 \item
 \ttt{real\_precision}\\
 Predefined integer; the decimal precision of the floating point type
 of the \fortran\ compiler with which \whizard\ has been built.
 %%%%%
 \item
 \ttt{real\_range}\\
 Predefined integer; the decimal range of the floating point type of
 the \fortran\ compiler with which \whizard\ has been built.
 %%%%%
 \item
 \ttt{real\_tiny}\\
 Predefined real; the smallest number which can be represented by the
 floating point type of the \fortran\ compiler with which \whizard\ has
 been built.
 %%%%%
 \item
 \ttt{record} \newline
 The \ttt{record} constructor provides an internal data structure in
 \sindarin\ input files. Its syntax is in general \ttt{record
   {\em <record\_name>} ({\em <cmd\_expr>})}. The \ttt{{\em <cmd\_expr>}} could be the
 definition of a tuple of points for a histogram or an \ttt{eval}
 constructor that tells \whizard\ e.g. by which rule to calculate an
 observable to be stored in the record \ttt{record\_name}. Example:
 \ttt{record h (12)} is a record for a histogram defined under the name
 \ttt{h} with the single data point (bin) at value 12; \ttt{record rap1
 (eval Rap [e1])} defines a record with name \ttt{rap1} which has an
 evaluator to calculate the rapidity (predefined \whizard\ function) of
 an outgoing electron.
 (cf. also \ttt{eval}, \ttt{histogram}, \ttt{plot})
 %%%%%
 \item
 \ttt{renormalization\_scale} \newline
 This is a command, \ttt{renormalization\_scale = {\em <expr>}}, that sets
 the renormalization scale of a process or list of processes. It
 overwrites a possible scale set by the ($\to$) \ttt{scale} command.
 \ttt{{\em <expr>}} can be any kinematic expression that leads to a result of
 momentum dimension one, e.g. \ttt{100 GeV}, \ttt{eval
 Pt [e1]}. (cf. also \ttt{factorization\_scale}).
 %%%%%
 \item
 \ttt{rescan} \newline
 This command allows to rescan event samples with modified model
 parameter, beam structure etc. to recalculate (analysis) observables,
 e.g.: \newline
 \ttt{rescan "{\em <event\_file>}" ({\em <proc\_name>}) \{ {\em <rescan\_setup>}\}}.
 \newline
 \ttt{"{\em <event\_file>}"} is the name of the event file and
 \ttt{{\em <proc\_name>}} is the process whose (existing) event
 file of arbitrary size that is to be rescanned. Several flags allow to
 reconstruct the beams ($\to$ \ttt{?recover\_beams}), to reuse only the
 hard process but rebuild the full events ($\to$
 \ttt{?update\_event}), to recalculate the matrix element ($\to$
 \ttt{?update\_sqme}) or to recalculate the individual event weight ($\to$
 \ttt{?update\_weight}). Further rescan options are redefining model
 parameter input, or defining a completely new alternative setup ($\to$
 \ttt{alt\_setup}) (cf. also \ttt{\$rescan\_input\_format})
 %%%%%
 \item
 \ttt{results} \newline
 Only used in the combination \ttt{show (results)}. Forces \whizard\ to
 print out a results summary for the integrated processes.
 (cf. also \ttt{show})
 %%%%%
 \item
 \ttt{reweight} \newline
 The \ttt{reweight = {\em <expr>}} command allows to give for a process or
 list of processes an alternative weight, given by any kind of scalar
 expression \ttt{{\em <expr>}}, e.g. \ttt{reweight = 0.2} or \ttt{reweight =
 (eval M2 [e1, E1]) / (eval M2 [e2, E2])}. (cf. also \ttt{alt\_setup},
 \ttt{weight}, \ttt{rescan})
 %%%%%
 \item
 \ttt{sample\_format} \newline
 Variable that allows the user to specify additional event formats
 beyond the \whizard\ native binary event format. Its syntax is
 \ttt{sample\_format = {\em <format>}}, where \ttt{{\em <format>}} can be any of
 the following specifiers: \ttt{hepevt}, \ttt{hepevt\_verb}, \ttt{ascii},
 \ttt{athena}, \ttt{debug}, \ttt{long}, \ttt{short}, \ttt{hepmc},
 \ttt{lhef}, \ttt{lha}, \ttt{lha\_verb}, \ttt{stdhep}, \ttt{stdhep\_up}.
 (cf. also \ttt{\$sample}, \ttt{simulate}, \ttt{hepevt}, \ttt{ascii},
 \ttt{athena}, \ttt{debug}, \ttt{long}, \ttt{short}, \ttt{hepmc},
 \ttt{lhef}, \ttt{lha}, \ttt{stdhep}, \ttt{stdhep\_up}, \newline
 \ttt{\$sample\_normalization}, \ttt{?sample\_pacify},
 \ttt{sample\_max\_tries}, \ttt{sample\_split\_n\_evt},
 \ttt{sample\_split\_n\_kbytes})
 %%%%%
 \item
 \ttt{scale} \newline
 This is a command, \ttt{scale = {\em <expr>}}, that sets the kinematic scale
 of a process or list of processes. Unless overwritten explicitly by
 ($\to$) \ttt{factorization\_scale} and/or ($\to$)
 \ttt{renormalization\_scale} it sets both scales. \ttt{{\em <expr>}} can be
 any kinematic expression that leads to a result of momentum dimension
 one, e.g. \ttt{scale = 100 GeV}, \ttt{scale = eval Pt [e1]}.
 %%%%%
 \item
 \ttt{scan} \newline
 Constructor to perform loops over variables or scan over processes in
 the integration procedure. The syntax is \ttt{scan {\em <var>} {\em <var\_name>}
   ({\em <value list>} or  {\em <value\_init>} => {\em <value\_fin>} /{\em <incrementor>}
   {\em <increment>}) \{ {\em <scan\_cmd>} \}}. The variable \ttt{var} can be
 specified if it is not a real, e.g. an integer. \ttt{var\_name} is the
 name of the variable which is also allowed to be a predefined one like
 \ttt{seed}. For the scan, one can either specify an explicit list of
 values \ttt{value list}, or use an initial and final value and a
 rule to increment. The \ttt{scan\_cmd}  can either be just a
 \ttt{show} to print out the scanned variable or the integration of a process.
 Examples are: \ttt{scan seed (32 => 1 // 2) \{ show (seed\_value) \}
 }, which runs the seed down in steps 32, 16, 8, 4, 2, 1 (division by
 two). \ttt{scan mW (75 GeV, 80 GeV => 82 GeV /+ 0.5 GeV,  83 GeV => 90
 GeV /* 1.2) \{ show (sw) \} } scans over the $W$ mass for the values
 75, 80, 80.5, 81, 81.5, 82, 83 GeV, namely one discrete value, steps
 by adding 0.5 GeV, and increase by 20 \% (the latter having no effect
 as it already exceeds the final value). It prints out the
 corresponding value of the effective mixing angle which is defined as
 a dependent variable in the model input file(s). \ttt{scan sqrts (500 GeV =>
   600 GeV /+ 10 GeV) \{ integrate (proc) \} } integrates the process
 \ttt{proc} in eleven increasing 10 GeV steps in center-of-mass energy
 from 500 to 600 GeV. (cf. also \ttt{/+}, \ttt{/+/}, \ttt{/-},
 \ttt{/*}, \ttt{/*/}, \ttt{//})
 %%%%%
 \item
 \ttt{select} \newline
 Subevent function \ttt{select if {\em <condition>} [{\em <list1>} [ ,
   {\em <list2>}]]} that select all particles in \ttt{{\em <list1>}}
 that satisfy the condition \ttt{{\em <condition>}}. The second
 particle list \ttt{{\em <list2>}} is for conditions that depend on
 binary observables. (cf. also \ttt{collect},
 \ttt{combine}, \ttt{extract}, \ttt{sort}, \ttt{+})
 %%%%%
 \item
 \ttt{selection} \newline
 Command that allows to select particular final states in an analysis
 selection, \ttt{selection = {\em <log\_expr>}}. The term \ttt{log\_expr} can
 be any kind of logical expression. The syntax matches exactly
 the one of the ($\to$) \ttt{cuts} command. E.g. \ttt{selection = any
 PDG == 13} is an electron selection in a lepton sample.
 %%%%%
 \item
 \ttt{sgn} \newline
 Numerical function for integer and real numbers that gives the sign of
 its argument: \ttt{sgn ({\em <num\_val>})} yields $+1$ if \ttt{{\em
 <num\_val>}} is positive or zero, and $-1$ otherwise. (cf. also
 \ttt{abs}, \ttt{conjg}, \ttt{mod}, \ttt{modulo})
 %%%%%
 \item
 \ttt{short} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of the short variant of HEPEVT ASCII event
 files. (cf. also \ttt{\$sample}, \ttt{sample\_format})
 %%%%%
 \item
 \ttt{show} \newline
 This is a unary function that is operating on specific constructors in
 order to print them out in the \whizard\ screen output as well as the
 log file \ttt{whizard.log}. Examples are \ttt{show({\em <parameter\_name>})}
 to issue a specific parameter from a model or a constant defined in a
 \sindarin\ input file, \ttt{show(integral({\em <proc\_name>}))},
 \ttt{show(library)}, \ttt{show(results)}, or \ttt{show({\em <var>})} for any
 arbitrary variable. Further possibilities are \ttt{show(real)},
 \ttt{show(string)}, \ttt{show(logical)} etc. to allow to show all
 defined real, string, logical etc. variables, respectively.
 (cf. also \ttt{library}, \ttt{results})
 %%%%%
 \item
 \ttt{simulate} \newline
 This command invokes the generation of events for the process
 \ttt{proc} by means of \ttt{simulate ({\em <proc>})}.
 Optional arguments: \ttt{\$sample}, \ttt{sample\_format},
 \ttt{checkpoint} (cf. also \ttt{integrate}, \ttt{luminosity},
 \ttt{n\_events}, \ttt{\$sample}, \ttt{sample\_format},
 \ttt{checkpoint}, \ttt{?unweighted}, \ttt{safety\_factor},
 \ttt{?negative\_weights}, \ttt{sample\_max\_tries},
 \ttt{sample\_split\_n\_evt}, \ttt{sample\_split\_n\_kbytes})
 %%%%%
 \item
 \ttt{sin} \newline
 Numerical function \ttt{sin ({\em <num\_val>})} that calculates the
 sine trigonometric function of real and complex numerical numbers or
 variables. (cf. also \ttt{cos}, \ttt{tan}, \ttt{asin}, \ttt{acos},
 \ttt{atan})
 %%%%%
 \item
 \ttt{sinh} \newline
 Numerical function \ttt{sinh ({\em <num\_val>})} that calculates the
 hyperbolic sine function of real and complex numerical numbers or
 variables. Note that its inverse function is part of the
 \ttt{Fortran2008} status and hence not realized. (cf. also \ttt{cosh},
 \ttt{tanh})
 %%%%%
 \item
 \ttt{sort} \newline
 Subevent function that allows to sort a particle list/subevent either
 by increasing PDG code: \ttt{sort [{\em <particles>}]} (particles
 first, then antiparticles). Alternatively, it can sort according to a
 unary or binary particle observable (in that case there is a second
 particle list, where the first particle is taken as a reference):
 \ttt{sort by {\em <observable>} [{\em <particles>} [, {\em
 <ref\_particles>}]]}. (cf. also \ttt{extract}, \ttt{combine},
 \ttt{collect}, \ttt{join}, \ttt{by}, \ttt{+})
 %%%%%
 \item
 \ttt{sprintf} \newline
 Command that allows to print data into a string variable: \ttt{sprintf
 "{\em <string\_expr>}"}. There exist format specifiers, very similar
 to the \ttt{C} command \ttt{sprintf}, e.g. \ttt{sprintf "\%i"
 (123)}. (cf. \ttt{printf}, \ttt{\%d}, \ttt{\%i}, \ttt{\%e},
 \ttt{\%f}, \ttt{\%g}, \ttt{\%E}, \ttt{\%F}, \ttt{\%G}, \ttt{\%s})
 %%%%%
 \item
 \ttt{sqrt} \newline
 Numerical function \ttt{sqrt ({\em <num\_val>})} that calculates the
 square root of real and complex numerical numbers or
 variables. (cf. also \ttt{exp}, \ttt{log}, \ttt{log10})
 %%%%%
 \item
 \ttt{sqrts\_hat} \newline
 Real variable that accesses the partonic energy of a hard-scattering
 process. It can be used in cuts or in an analysis, e.g. \ttt{cuts =
 sqrts\_hat > {\em <num>} [ {\em <phys\_unit>} ]}. The physical unit
 can be one of the following \ttt{eV}, \ttt{keV}, \ttt{MeV}, \ttt{GeV},
 and \ttt{TeV}. (cf. also \ttt{sqrts}, \ttt{cuts}, \ttt{record})
 %%%%%
 \item
 \ttt{stable} \newline
 This constructor allows particles in the final states of processes in
 decay cascade set-up to be set as stable, and not letting them
 decay. The syntax is \ttt{stable {\em <prt\_name>}} (cf. also \ttt{unstable})
 %%%%%
 \item
 \ttt{stdhep} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of binary StdHEP event files based on the HEPEVT common
 block. (cf. also \ttt{\$sample}, \ttt{sample\_format})
 %%%%%
 \item
 \ttt{stdhep\_up} \newline
 Specifier for the \ttt{sample\_format} command to demand the
 generation of binary StdHEP event files based on the HEPRUP/HEPEUP common
 blocks. (cf. also \ttt{\$sample}, \ttt{sample\_format})
 %%%%%
 \item
 \ttt{tan} \newline
 Numerical function \ttt{tan ({\em <num\_val>})} that calculates the
 tangent trigonometric function of real and complex numerical numbers or
 variables. (cf. also \ttt{sin}, \ttt{cos}, \ttt{asin}, \ttt{acos},
 \ttt{atan})
 %%%%%
 \item
 \ttt{tanh} \newline
 Numerical function \ttt{tanh ({\em <num\_val>})} that calculates the
 hyperbolic tangent function of real and complex numerical numbers or
 variables. Note that its inverse function is part of the
 \ttt{Fortran2008} status and hence not realized. (cf. also \ttt{cosh},
 \ttt{sinh})
 %%%%%
 \item
 \ttt{TeV} \newline
 Physical unit, for energies in $10^{12}$ electron volt. (cf. also
 \ttt{eV}, \ttt{keV}, \ttt{MeV}, \ttt{meV}, \ttt{GeV})
 %%%%
 \item
 \ttt{then} \newline
 Mandatory phrase in a conditional clause: \ttt{if {\em <log\_expr>} then
   {\em <expr 1>} \ldots endif}. (cf. also \ttt{if}, \ttt{else}, \ttt{elsif},
 \ttt{endif}).
 %%%%%
 \item
 \ttt{Theta} \newline
 Unary and also binary observable specifier, that as a unary observable
 gives the angle between a particle's momentum and the beam axis ($+z$
 direction). As a binary observable, it gives the angle enclosed
 between the momenta of the two particles: \ttt{eval Theta [e1]},
 \ttt{all Theta > 30 degrees [jet, jet]}. (cf. also \ttt{eval},
 \ttt{cuts}, \ttt{selection}, \ttt{Phi}, \ttt{Theta\_star})
 %%%%%
 \item
 \ttt{Theta\_star} \newline
 Binary observable specifier, that gives the polar angle enclosed
 between the momenta of the two particles in the rest frame of the
 mother particle (momentum sum of the two particle): \ttt{eval
 Theta\_star [jet, jet]}. (cf. also \ttt{eval},
 \ttt{cuts}, \ttt{selection}, \ttt{Theta})
 %%%%%
 \item
 \ttt{true} \newline
 Constructor stating that a logical expression or variable is true,
 e.g. \ttt{?{\em <log\_var>} = true}. (cf. also \ttt{false}).
 %%%%%
 \item
 \ttt{unpolarized} \newline
 Constructor to force \whizard\ to discard polarization of the
 corresponding particles in the generated events: \ttt{unpolarized {\em <prt1>}
   [, {\em <prt2>} , ...]}. (cf. also \ttt{polarized}, \ttt{simulate},
 \ttt{?polarized\_events})
 %%%%%
 \item
 \ttt{unstable} \newline
 This constructor allows to let final state particles of the hard
 interaction undergo a subsequent (cascade) decay (in the on-shell
 approximation). For this the user has to define the list of desired
 \begin{figure}
   \begin{Verbatim}[frame=single]
     process zee =   Z => e1, E1
     process zuu =   Z => u, U
     process zz = e1, E1 => Z, Z
     compile
     integrate (zee) { iterations = 1:100 }
     integrate (zuu) { iterations = 1:100 }
     sqrts = 500 GeV
     integrate (zz) { iterations = 3:5000, 2:5000 }
     unstable Z (zee, zuu)
  \end{Verbatim}
   \caption{\label{fig:ex_unstable} \sindarin\ input file for unstable
     particles and inclusive decays.}
 \end{figure}
 decay channels as \ttt{unstable {\em <mother>} ({\em <decay1>}, {\em <decay2>}, ....)},
 where \ttt{mother} is the mother particle, and the argument is a list
 of decay channels. Note that -- unless the \ttt{?auto\_decays = true}
 flag has been set -- these decay channels have to be provided by the
 user as  in the example in Fig. \ref{fig:ex_unstable}. First, the $Z$
 decays to electrons and up quarks are generated, then $ZZ$ production
 at a 500 GeV ILC is called, and then both $Z$s are decayed according
 to the probability distribution of the two generated decay matrix
 elements. This obviously allows also for inclusive decays.
 (cf. also \ttt{stable}, \ttt{?auto\_decays})
 %%%%%
 \item
 \ttt{weight} \newline
 This is a command, \ttt{weight = {\em <expr>}}, that allows to specify a
 weight for a process or list of processes. \ttt{{\em <expr>}} can be
 any expression that leads to a scalar result, e.g. \ttt{weight = 0.2},
 \ttt{weight = eval Pt [jet]}.  (cf. also \ttt{rescan},
 \ttt{alt\_setup}, \ttt{reweight})
 %%%%%
 \item
 \ttt{write\_analysis} \newline
 The \ttt{write\_analysis} statement tells \whizard\ to write the
 analysis setup by the user for the \sindarin\ input file under
 consideration. If no \ttt{\$out\_file} is provided, the histogram
 tables/plot data etc. are written to the default file
 \ttt{whizard\_analysis.dat}. Note that the related command
 \ttt{compile\_analysis} does the same as \ttt{write\_analysis} but in
 addition invokes the \whizard\ \LaTeX routines for producing
 postscript or PDF output of the data.
 (cf. also \ttt{\$out\_file}, \ttt{compile\_analysis})
 %%%%%
 \item
 \ttt{write\_slha} \newline
 Demands \whizard\ to write out a file in the SUSY Les Houches accord
 (SLHA) format. (cf. also \ttt{read\_slha}, \ttt{?slha\_read\_decays},
 \ttt{?slha\_read\_input}, \ttt{?slha\_read\_spectrum})
 %%%%%
 \end{itemize}
 \section{Variables}
 \subsection{Rebuild Variables}
 \begin{itemize}
 \item
 \ttt{?rebuild\_events} \qquad (default: \ttt{false}) \newline
 This logical variable, if set \ttt{true} triggers \whizard\ to newly
 create an event sample, even if nothing seems to have changed,
 including the MD5 checksum. This can be used when manually
 manipulating some settings. (cf also \ttt{?rebuild\_grids},
 \ttt{?rebuild\_library}, \ttt{?rebuild\_phase\_space})
 %%%%%
 \item
 \ttt{?rebuild\_grids} \qquad (default: \ttt{false}) \newline
 The logical variable \ttt{?rebuild\_grids} forces \whizard\ to newly
 create the VAMP grids when using VAMP as an integration method, even
 if they are already present. (cf. also \ttt{?rebuild\_events},
 \ttt{?rebuild\_library}, \ttt{?rebuild\_phase\_space})
 %%%%%
 \item
 \ttt{?rebuild\_library} \qquad (default: \ttt{false}) \newline
 The logical variable \ttt{?rebuild\_library = true/false} specifies
 whether the library(-ies) for the matrix element code for processes is
 re-generated (incl. possible Makefiles etc.) by the corresponding ME
 method (e.g. if the process has been changed, but not its name). This
 can also be set as a command-line option \ttt{whizard --rebuild}. The
 default is \ttt{false}, i.e. code is never re-generated if it is
 present and the MD5 checksum is valid.
 (cf. also \ttt{?recompile\_library}, \ttt{?rebuild\_grids},
 \ttt{?rebuild\_phase\_space})
 %%%%%
 \item
 \ttt{?rebuild\_phase\_space} \qquad (default: \ttt{false}) \newline
 This logical variable, if set \ttt{true}, triggers recreation of the
 phase space file by \whizard\. (cf. also \ttt{?rebuild\_events},
 \ttt{?rebuild\_grids}, \ttt{?rebuild\_library})
 %%%%%
 \item
 \ttt{?recompile\_library} \qquad (default: \ttt{false}) \newline
 The logical variable \ttt{?recompile\_library = true/false} specifies
 whether the library(-ies) for the matrix element code for processes is
 re-compiled (e.g. if the process code has been manually modified by
 the user). This can also be set as a command-line option \ttt{whizard
   --recompile}. The default is \ttt{false}, i.e. code is never
 re-compiled if its corresponding object file is present. (cf. also
 \ttt{?rebuild\_library})
 %%%%%
 \end{itemize}
 \subsection{Standard Variables}
 \begin{itemize}
 \input{variables}
 \end{itemize}
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \clearpage
 \section*{Acknowledgements}
 
 We would like to thank E.~Boos, R.~Chierici, K.~Desch, M.~Kobel,
 F.~Krauss, P.M.~Manakos, N.~Meyer, K.~M\"onig, H.~Reuter, T.~Robens,
 S.~Rosati, J.~Schumacher, M.~Schumacher, and C.~Schwinn who
 contributed to \whizard\ by their suggestions, bits of codes and
 valuable remarks and/or used several versions of the program for
 real-life applications and thus helped a lot in debugging and
 improving the code.  Special thanks go to A.~Vaught and J.~Weill for
 their continuos efforts on improving the g95 and gfortran compilers,
 respectively.
 
 %\end{fmffile}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%% References
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %\baselineskip15pt
 \begin{thebibliography}{19}
 
 \bibitem{PYTHIA}
   T.~Sj\"ostrand,
   Comput.\ Phys.\ Commun.\ \textbf{82} (1994) 74.
 
 \bibitem{comphep}
   A.~Pukhov, \emph{et al.},
   Preprint INP MSU 98-41/542, \ttt{hep-ph/9908288}.
 
 \bibitem{madgraph}
   T.~Stelzer and W.F.~Long,
   Comput.\ Phys.\ Commun.\ \textbf{81} (1994) 357.
 
 \bibitem{omega}
   T.~Ohl,
   \emph{Proceedings of the Seventh International Workshop on
   Advanced Computing and Analysis Technics in Physics Research},
   ACAT 2000, Fermilab, October 2000,
   IKDA-2000-30, \ttt{hep-ph/0011243};
   M.~Moretti, Th.~Ohl, and J.~Reuter,
   LC-TOOL-2001-040
 
 \bibitem{VAMP}
   T.~Ohl,
   {\em Vegas revisited: Adaptive Monte Carlo integration beyond
     factorization},
   Comput.\ Phys.\ Commun.\  {\bf 120}, 13 (1999)
   [arXiv:hep-ph/9806432].
   %%CITATION = CPHCB,120,13;%%
 
 \bibitem{CIRCE}
   T.~Ohl,
   {\em CIRCE version 1.0: Beam spectra for simulating linear collider
     physics},
   Comput.\ Phys.\ Commun.\  {\bf 101}, 269 (1997)
   [arXiv:hep-ph/9607454].
   %%CITATION = CPHCB,101,269;%%
 
 %\cite{Gribov:1972rt}
 \bibitem{Gribov:1972rt}
   V.~N.~Gribov and L.~N.~Lipatov,
   {\em e+ e- pair annihilation and deep inelastic e p scattering in
     perturbation theory},
   Sov.\ J.\ Nucl.\ Phys.\  {\bf 15}, 675 (1972)
   [Yad.\ Fiz.\  {\bf 15}, 1218 (1972)].
   %%CITATION = SJNCA,15,675;%%
 
 %\cite{Kuraev:1985hb}
 \bibitem{Kuraev:1985hb}
   E.~A.~Kuraev and V.~S.~Fadin,
   {\em On Radiative Corrections to e+ e- Single Photon Annihilation at
     High-Energy},
   Sov.\ J.\ Nucl.\ Phys.\  {\bf 41}, 466 (1985)
   [Yad.\ Fiz.\  {\bf 41}, 733 (1985)].
   %%CITATION = SJNCA,41,466;%%
 
 %\cite{Skrzypek:1990qs}
 \bibitem{Skrzypek:1990qs}
   M.~Skrzypek and S.~Jadach,
   {\em Exact and approximate solutions for the electron nonsinglet
     structure function in QED},
   Z.\ Phys.\ C {\bf 49}, 577 (1991).
   %%CITATION = ZEPYA,C49,577;%%
 
 %\cite{Schulte:1998au}
 \bibitem{Schulte:1998au}
   D.~Schulte,
   {\em Beam-beam simulations with Guinea-Pig},
   eConf C {\bf 980914}, 127 (1998).
   %%CITATION = ECONF,C980914,127;%%
 
 %\cite{Schulte:1999tx}
 \bibitem{Schulte:1999tx}
   D.~Schulte,
   {\em Beam-beam simulations with GUINEA-PIG},
   CERN-PS-99-014-LP.
   %%CITATION = CERN-PS-99-014-LP;%%
 
 %\cite{Schulte:2007zz}
 \bibitem{Schulte:2007zz}
   D.~Schulte, M.~Alabau, P.~Bambade, O.~Dadoun, G.~Le Meur, C.~Rimbault and F.~Touze,
   {\em GUINEA PIG++ : An Upgraded Version of the Linear Collider Beam
     Beam Interaction Simulation Code GUINEA PIG},
   Conf.\ Proc.\ C {\bf 070625}, 2728 (2007).
   %%CITATION = CONFP,C070625,2728;%%
 
 %\cite{Behnke:2013xla}
 \bibitem{Behnke:2013xla}
   T.~Behnke, J.~E.~Brau, B.~Foster, J.~Fuster, M.~Harrison, J.~M.~Paterson, M.~Peskin and M.~Stanitzki {\it et al.},
   {\em The International Linear Collider Technical Design Report -
     Volume 1: Executive Summary},
   arXiv:1306.6327 [physics.acc-ph].
   %%CITATION = ARXIV:1306.6327;%%
 
 %\cite{Baer:2013cma}
 \bibitem{Baer:2013cma}
   H.~Baer, T.~Barklow, K.~Fujii, Y.~Gao, A.~Hoang, S.~Kanemura, J.~List and H.~E.~Logan {\it et al.},
   {\em The International Linear Collider Technical Design Report -
     Volume 2: Physics},
   arXiv:1306.6352 [hep-ph].
   %%CITATION = ARXIV:1306.6352;%%
 
 %\cite{Adolphsen:2013jya}
 \bibitem{Adolphsen:2013jya}
   C.~Adolphsen, M.~Barone, B.~Barish, K.~Buesser, P.~Burrows, J.~Carwardine, J.~Clark and H\'{e}l\`{e}n.~M.~Durand {\it et al.},
   {\em The International Linear Collider Technical Design Report -
     Volume 3.I: Accelerator \& in the Technical Design Phase},
   arXiv:1306.6353 [physics.acc-ph].
   %%CITATION = ARXIV:1306.6353;%%
 
 %\cite{Adolphsen:2013kya}
 \bibitem{Adolphsen:2013kya}
   C.~Adolphsen, M.~Barone, B.~Barish, K.~Buesser, P.~Burrows, J.~Carwardine, J.~Clark and H\'{e}l\`{e}n.~M.~Durand {\it et al.},
   {\em The International Linear Collider Technical Design Report -
     Volume 3.II: Accelerator Baseline Design},
   arXiv:1306.6328 [physics.acc-ph].
   %%CITATION = ARXIV:1306.6328;%%
 
 %\cite{Behnke:2013lya}
 \bibitem{Behnke:2013lya}
   T.~Behnke, J.~E.~Brau, P.~N.~Burrows, J.~Fuster, M.~Peskin, M.~Stanitzki, Y.~Sugimoto and S.~Yamada {\it et al.},
   %``The International Linear Collider Technical Design Report - Volume 4: Detectors,''
   arXiv:1306.6329 [physics.ins-det].
   %%CITATION = ARXIV:1306.6329;%%
 
 %\cite{Aicheler:2012bya}
 \bibitem{Aicheler:2012bya}
   M.~Aicheler, P.~Burrows, M.~Draper, T.~Garvey, P.~Lebrun, K.~Peach and N.~Phinney {\it et al.},
   {\em A Multi-TeV Linear Collider Based on CLIC Technology : CLIC
     Conceptual Design Report},
   CERN-2012-007.
   %%CITATION = CERN-2012-007;%%
 
 %\cite{Lebrun:2012hj}
 \bibitem{Lebrun:2012hj}
   P.~Lebrun, L.~Linssen, A.~Lucaci-Timoce, D.~Schulte, F.~Simon, S.~Stapnes, N.~Toge and H.~Weerts {\it et al.},
   {\em The CLIC Programme: Towards a Staged e+e- Linear Collider
     Exploring the Terascale : CLIC Conceptual Design Report},
   arXiv:1209.2543 [physics.ins-det].
   %%CITATION = ARXIV:1209.2543;%%
 
 %\cite{Linssen:2012hp}
 \bibitem{Linssen:2012hp}
   L.~Linssen, A.~Miyamoto, M.~Stanitzki and H.~Weerts,
   {\em Physics and Detectors at CLIC: CLIC Conceptual Design Report},
   arXiv:1202.5940 [physics.ins-det].
   %%CITATION = ARXIV:1202.5940;%%
 
 %\cite{vonWeizsacker:1934sx}
 \bibitem{vonWeizsacker:1934sx}
   C.~F.~von Weizs\"acker,
   {\em Radiation emitted in collisions of very fast electrons},
   Z.\ Phys.\  {\bf 88}, 612 (1934).
   %%CITATION = ZEPYA,88,612;%%
 
 %\cite{Williams:1934ad}
 \bibitem{Williams:1934ad}
   E.~J.~Williams,
   {\em Nature of the high-energy particles of penetrating radiation
     and status of ionization and radiation formulae},
   Phys.\ Rev.\  {\bf 45}, 729 (1934).
   %%CITATION = PHRVA,45,729;%%
 
 %\cite{Budnev:1974de}
 \bibitem{Budnev:1974de}
   V.~M.~Budnev, I.~F.~Ginzburg, G.~V.~Meledin and V.~G.~Serbo,
   {\em The Two photon particle production mechanism. Physical problems.
   Applications. Equivalent photon approximation},
   Phys.\ Rept.\  {\bf 15} (1974) 181.
   %%CITATION = PRPLC,15,181;%%
 
 %\cite{Ginzburg:1981vm}
 \bibitem{Ginzburg:1981vm}
   I.~F.~Ginzburg, G.~L.~Kotkin, V.~G.~Serbo and V.~I.~Telnov,
   {\em Colliding gamma e and gamma gamma Beams Based on the Single
     Pass Accelerators (of Vlepp Type)},
   Nucl.\ Instrum.\ Meth.\  {\bf 205}, 47 (1983).
   %%CITATION = NUIMA,205,47;%%
 
 %\cite{Telnov:1989sd}
 \bibitem{Telnov:1989sd}
   V.~I.~Telnov,
   {\em Problems of Obtaining $\gamma \gamma$ and $\gamma \epsilon$
     Colliding Beams at Linear Colliders},
   Nucl.\ Instrum.\ Meth.\ A {\bf 294}, 72 (1990).
   %%CITATION = NUIMA,A294,72;%%
 
 %\cite{Telnov:1995hc}
 \bibitem{Telnov:1995hc}
   V.~I.~Telnov,
   {\em Principles of photon colliders},
   Nucl.\ Instrum.\ Meth.\ A {\bf 355}, 3 (1995).
   %%CITATION = NUIMA,A355,3;%%
 
 %\cite{AguilarSaavedra:2001rg}
 \bibitem{AguilarSaavedra:2001rg}
   J.~A.~Aguilar-Saavedra {\it et al.}  [ECFA/DESY LC Physics Working
   Group Collaboration],
   {\em TESLA: The Superconducting electron positron linear collider
     with an integrated x-ray laser laboratory. Technical design
     report. Part 3. Physics at an e+ e- linear collider},
   hep-ph/0106315.
   %%CITATION = HEP-PH/0106315;%%
 
 %\cite{Richard:2001qm}
 \bibitem{Richard:2001qm}
   F.~Richard, J.~R.~Schneider, D.~Trines and A.~Wagner,
   {\em TESLA, The Superconducting Electron Positron Linear Collider
     with an Integrated X-ray Laser Laboratory, Technical Design Report
     Part 1 : Executive Summary},
   hep-ph/0106314.
   %%CITATION = HEP-PH/0106314;%%
 
 %\cite{Sudakov:1954sw}
 \bibitem{Sudakov:1954sw}
   V.~V.~Sudakov,
   %``Vertex parts at very high-energies in quantum electrodynamics,''
   Sov.\ Phys.\ JETP {\bf 3}, 65 (1956)
   [Zh.\ Eksp.\ Teor.\ Fiz.\  {\bf 30}, 87 (1956)].
   %%CITATION = SPHJA,3,65;%%
 
 \cite{Sjostrand:1985xi}
 \bibitem{Sjostrand:1985xi}
   T.~Sjostrand,
   %``A Model for Initial State Parton Showers,''
   Phys.\ Lett.\  {\bf 157B}, 321 (1985).
   doi:10.1016/0370-2693(85)90674-4
   %%CITATION = doi:10.1016/0370-2693(85)90674-4;%%
 
 %\cite{Sjostrand:2006za}
 \bibitem{Sjostrand:2006za}
   T.~Sjostrand, S.~Mrenna and P.~Z.~Skands,
   %``PYTHIA 6.4 Physics and Manual,''
   JHEP {\bf 0605}, 026 (2006)
   doi:10.1088/1126-6708/2006/05/026
   [hep-ph/0603175].
   %%CITATION = doi:10.1088/1126-6708/2006/05/026;%%
 
 %\cite{Ohl:1998jn}
 \bibitem{Ohl:1998jn}
   T.~Ohl,
   {\em Vegas revisited: Adaptive Monte Carlo integration beyond
     factorization},
   Comput.\ Phys.\ Commun.\  {\bf 120}, 13 (1999)
   [hep-ph/9806432].
   %%CITATION = HEP-PH/9806432;%%
 
 %\cite{Lepage:1980dq}
 \bibitem{Lepage:1980dq}
   G.~P.~Lepage,
   %``Vegas: An Adaptive Multidimensional Integration Program,''
   CLNS-80/447.
   %%CITATION = CLNS-80/447;%%
 
 \bibitem{HDECAY}
   A.~Djouadi, J.~Kalinowski, M.~Spira,
   Comput.\ Phys.\ Commun.\ \textbf{108} (1998) 56-74.
 
 %\cite{Beyer:2006hx}
 \bibitem{Beyer:2006hx}
   M.~Beyer, W.~Kilian, P.~Krstono\v{s}ic, K.~M\"onig, J.~Reuter, E.~Schmidt
   and H.~Schr\"oder,
   {\em Determination of New Electroweak Parameters at the ILC -
     Sensitivity to New Physics},
   Eur.\ Phys.\ J.\ C {\bf 48}, 353 (2006)
   [hep-ph/0604048].
   %%CITATION = HEP-PH/0604048;%%
 
 %\cite{Alboteanu:2008my}
 \bibitem{Alboteanu:2008my}
   A.~Alboteanu, W.~Kilian and J.~Reuter,
   {\em Resonances and Unitarity in Weak Boson Scattering at the LHC},
   JHEP {\bf 0811}, 010 (2008)
   [arXiv:0806.4145 [hep-ph]].
   %%CITATION = ARXIV:0806.4145;%%
 
 %\cite{Binoth:2010xt}
 \bibitem{Binoth:2010xt} 
   T.~Binoth {\it et al.},
   %``A Proposal for a standard interface between Monte Carlo tools and one-loop programs,''
   Comput.\ Phys.\ Commun.\  {\bf 181}, 1612 (2010)
   doi:10.1016/j.cpc.2010.05.016
   [arXiv:1001.1307 [hep-ph]].
   %%CITATION = doi:10.1016/j.cpc.2010.05.016;%%
   
 %\cite{Alioli:2013nda}
 \bibitem{Alioli:2013nda} 
   S.~Alioli {\it et al.},
   %``Update of the Binoth Les Houches Accord for a standard interface
   %between Monte Carlo tools and one-loop programs,'' 
   Comput.\ Phys.\ Commun.\  {\bf 185}, 560 (2014)
   doi:10.1016/j.cpc.2013.10.020
   [arXiv:1308.3462 [hep-ph]].
   %%CITATION = doi:10.1016/j.cpc.2013.10.020;%%
   
 %\cite{Speckner:2010zi}
 \bibitem{Speckner:2010zi}
   C.~Speckner,
   {\em LHC Phenomenology of the Three-Site Higgsless Model},
   PhD thesis, arXiv:1011.1851 [hep-ph].
   %%CITATION = ARXIV:1011.1851;%%
 
 %\cite{Chivukula:2006cg}
 \bibitem{Chivukula:2006cg}
   R.~S.~Chivukula, B.~Coleppa, S.~Di Chiara, E.~H.~Simmons, H.~-J.~He,
   M.~Kurachi and M.~Tanabashi,
   {\em A Three Site Higgsless Model},
   Phys.\ Rev.\ D {\bf 74}, 075011 (2006)
   [hep-ph/0607124].
   %%CITATION = HEP-PH/0607124;%%
 
 %\cite{Chivukula:2005xm}
 \bibitem{Chivukula:2005xm}
   R.~S.~Chivukula, E.~H.~Simmons, H.~-J.~He, M.~Kurachi and M.~Tanabashi,
   {\em Ideal fermion delocalization in Higgsless models},
   Phys.\ Rev.\ D {\bf 72}, 015008 (2005)
   [hep-ph/0504114].
   %%CITATION = HEP-PH/0504114;%%
 
 %\cite{Ohl:2008ri}
 \bibitem{Ohl:2008ri}
   T.~Ohl and C.~Speckner,
   {\em Production of Almost Fermiophobic Gauge Bosons in the Minimal
     Higgsless Model at the LHC},
   Phys.\ Rev.\ D {\bf 78}, 095008 (2008)
   [arXiv:0809.0023 [hep-ph]].
   %%CITATION = ARXIV:0809.0023;%%
 
 %\cite{Ohl:2002jp}
 \bibitem{Ohl:2002jp}
   T.~Ohl and J.~Reuter,
   {\em Clockwork SUSY: Supersymmetric Ward and Slavnov-Taylor
     identities at work in Green's functions and scattering
     amplitudes},
   Eur.\ Phys.\ J.\ C {\bf 30}, 525 (2003)
   [hep-th/0212224].
   %%CITATION = HEP-TH/0212224;%%
 
 %\cite{Reuter:2009ex}
 \bibitem{Reuter:2009ex}
   J.~Reuter and F.~Braam,
   {\em The NMSSM implementation in WHIZARD},
   AIP Conf.\ Proc.\  {\bf 1200}, 470 (2010)
   [arXiv:0909.3059 [hep-ph]].
   %%CITATION = ARXIV:0909.3059;%%
 
 %\cite{Kalinowski:2008fk}
 \bibitem{Kalinowski:2008fk}
   J.~Kalinowski, W.~Kilian, J.~Reuter, T.~Robens and K.~Rolbiecki,
   {\em Pinning down the Invisible Sneutrino},
   JHEP {\bf 0810}, 090 (2008)
   [arXiv:0809.3997 [hep-ph]].
   %%CITATION = ARXIV:0809.3997;%%
 
 %\cite{Robens:2008sa}
 \bibitem{Robens:2008sa}
   T.~Robens, J.~Kalinowski, K.~Rolbiecki, W.~Kilian and J.~Reuter,
   {\em (N)LO Simulation of Chargino Production and Decay},
   Acta Phys.\ Polon.\ B {\bf 39}, 1705 (2008)
   [arXiv:0803.4161 [hep-ph]].
   %%CITATION = ARXIV:0803.4161;%%
 
 %\cite{Kilian:2004pp}
 \bibitem{Kilian:2004pp}
   W.~Kilian, D.~Rainwater and J.~Reuter,
   {\em Pseudo-axions in little Higgs models},
   Phys.\ Rev.\ D {\bf 71}, 015008 (2005)
   [hep-ph/0411213].
   %%CITATION = HEP-PH/0411213;%%
 
 %\cite{Kilian:2006eh}
 \bibitem{Kilian:2006eh}
   W.~Kilian, D.~Rainwater and J.~Reuter,
   {\em Distinguishing little-Higgs product and simple group models at
     the LHC and ILC},
   Phys.\ Rev.\ D {\bf 74}, 095003 (2006)
   [Erratum-ibid.\ D {\bf 74}, 099905 (2006)]
   [hep-ph/0609119].
   %%CITATION = HEP-PH/0609119;%%
 
 %\cite{Ohl:2004tn}
 \bibitem{Ohl:2004tn}
   T.~Ohl and J.~Reuter,
   {\em Testing the noncommutative standard model at a future photon
     collider},
   Phys.\ Rev.\ D {\bf 70}, 076007 (2004)
   [hep-ph/0406098].
   %%CITATION = HEP-PH/0406098;%%
 
 %\cite{Ohl:2010zf}
 \bibitem{Ohl:2010zf}
   T.~Ohl and C.~Speckner,
   {\em The Noncommutative Standard Model and Polarization in Charged
     Gauge Boson Production at the LHC},
   Phys.\ Rev.\ D {\bf 82}, 116011 (2010)
   [arXiv:1008.4710 [hep-ph]].
   %%CITATION = ARXIV:1008.4710;%%
 
 \bibitem{LesHouches}
   E.~Boos {\it et al.},
   {\em Generic user process interface for event generators},
   arXiv:hep-ph/0109068.
   %%CITATION = HEP-PH/0109068;%%
 
 \bibitem{Skands:2003cj}
   P.~Z.~Skands {\it et al.},
   {\em SUSY Les Houches Accord: Interfacing SUSY Spectrum Calculators, Decay
   Packages, and Event Generators},
   JHEP {\bf 0407}, 036 (2004)
   [arXiv:hep-ph/0311123].
   %%CITATION = JHEPA,0407,036;%%
 
 %\cite{AguilarSaavedra:2005pw}
 \bibitem{AguilarSaavedra:2005pw}
   J.~A.~Aguilar-Saavedra, A.~Ali, B.~C.~Allanach, R.~L.~Arnowitt, H.~A.~Baer, J.~A.~Bagger, C.~Balazs and V.~D.~Barger {\it et al.},
   {\em Supersymmetry parameter analysis: SPA convention and project},
   Eur.\ Phys.\ J.\ C {\bf 46}, 43 (2006)
   [hep-ph/0511344].
   %%CITATION = HEP-PH/0511344;%%
 
 %\cite{Allanach:2008qq}
 \bibitem{Allanach:2008qq}
   B.~C.~Allanach, C.~Balazs, G.~Belanger, M.~Bernhardt, F.~Boudjema, D.~Choudhury, K.~Desch and U.~Ellwanger {\it et al.},
   %``SUSY Les Houches Accord 2,''
   Comput.\ Phys.\ Commun.\  {\bf 180}, 8 (2009)
   [arXiv:0801.0045 [hep-ph]].
   %%CITATION = ARXIV:0801.0045;%%
 
 \bibitem{LHEF}
   J.~Alwall {\it et al.},
   {\em A standard format for Les Houches event files},
   Comput.\ Phys.\ Commun.\  {\bf 176}, 300 (2007)
   [arXiv:hep-ph/0609017].
   %%CITATION = CPHCB,176,300;%%
 
 \bibitem{Hagiwara:2005wg}
   K.~Hagiwara {\it et al.},
   {\em Supersymmetry simulations with off-shell effects for LHC and
     ILC},
   Phys.\ Rev.\  D {\bf 73}, 055005 (2006)
   [arXiv:hep-ph/0512260].
   %%CITATION = PHRVA,D73,055005;%%
 
 \bibitem{Allanach:2002nj}
   B.~C.~Allanach {\it et al.},
   {\em The Snowmass points and slopes: Benchmarks for SUSY searches},
   in {\it Proc. of the APS/DPF/DPB Summer Study on the Future of Particle Physics (Snowmass 2001) } ed. N.~Graf,
   Eur.\ Phys.\ J.\ C {\bf 25} (2002) 113
   [eConf {\bf C010630} (2001) P125]
   [arXiv:hep-ph/0202233].
   %%CITATION = HEP-PH 0202233;%%
 
 \bibitem{PeskinSchroeder}
   M.E. Peskin, D.V.Schroeder, {\em An Introduction to Quantum Field
     Theory}, Addison-Wesley Publishing Co., 1995.
 
 \bibitem{stdhep}
   L.~Garren, {\em StdHep, Monte Carlo Standardization at FNAL},
   Fermilab CS-doc-903,
   \url{http://cd-docdb.fnal.gov/cgi-bin/ShowDocument?docid=903}
 
 \bibitem{LHAPDF}
   W.~Giele {\it et al.},
   {\em The QCD / SM working group: Summary report},
   arXiv:hep-ph/0204316;
   %%CITATION = HEP-PH/0204316;%%
   M.~R.~Whalley, D.~Bourilkov and R.~C.~Group,
   {\em The Les Houches Accord PDFs (LHAPDF) and Lhaglue},
   arXiv:hep-ph/0508110;
   %%CITATION = HEP-PH/0508110;%%
   D.~Bourilkov, R.~C.~Group and M.~R.~Whalley,
   {\em LHAPDF: PDF use from the Tevatron to the LHC},
   arXiv:hep-ph/0605240.
   %%CITATION = HEP-PH/0605240;%%
 
 \bibitem{HepMC}
   M.~Dobbs and J.~B.~Hansen,
   {\em The HepMC C++ Monte Carlo event record for High Energy
     Physics},
   Comput.\ Phys.\ Commun.\  {\bf 134}, 41 (2001).
   %%CITATION = CPHCB,134,41;%%
 
 %\cite{Boos:2004kh}
 \bibitem{Boos:2004kh}
   E.~Boos {\it et al.}  [CompHEP Collaboration],
   %``CompHEP 4.4: Automatic computations from Lagrangians to events,''
   Nucl.\ Instrum.\ Meth.\ A {\bf 534}, 250 (2004)
   [hep-ph/0403113].
   %%CITATION = HEP-PH/0403113;%%
   %493 citations counted in INSPIRE as of 12 May 2014
 
 % Parton distributions
 %\cite{Pumplin:2002vw}
 \bibitem{Pumplin:2002vw}
   J.~Pumplin, D.~R.~Stump, J.~Huston {\it et al.},
   {\em New generation of parton distributions with uncertainties from
     global QCD analysis},
   JHEP {\bf 0207}, 012 (2002).
   [hep-ph/0201195].
 %\cite{Martin:2004dh}
 \bibitem{Martin:2004dh}
   A.~D.~Martin, R.~G.~Roberts, W.~J.~Stirling {\it et al.},
   {\em Parton distributions incorporating QED contributions},
   Eur.\ Phys.\ J.\  {\bf C39}, 155-161 (2005).
   [hep-ph/0411040].
 %\cite{Martin:2009iq}
 \bibitem{Martin:2009iq}
   A.~D.~Martin, W.~J.~Stirling, R.~S.~Thorne {\it et al.},
   {\em Parton distributions for the LHC},
   Eur.\ Phys.\ J.\  {\bf C63}, 189-285 (2009).
   [arXiv:0901.0002 [hep-ph]].
 %\cite{Lai:2010vv}
 \bibitem{Lai:2010vv}
   H.~L.~Lai, M.~Guzzi, J.~Huston, Z.~Li, P.~M.~Nadolsky, J.~Pumplin and C.~P.~Yuan,
   {\em New parton distributions for collider physics},
   Phys.\ Rev.\  D {\bf 82}, 074024 (2010)
   [arXiv:1007.2241 [hep-ph]].
   %%CITATION = PHRVA,D82,074024;%%
 %\cite{Owens:2012bv}
 \bibitem{Owens:2012bv}
   J.~F.~Owens, A.~Accardi and W.~Melnitchouk,
   {\em Global parton distributions with nuclear and finite-$Q^2$
     corrections},
   Phys.\ Rev.\ D {\bf 87}, no. 9, 094012 (2013)
   [arXiv:1212.1702 [hep-ph]].
   %%CITATION = ARXIV:1212.1702;%%
 %\cite{Accardi:2016qay}
 \bibitem{Accardi:2016qay}
   A.~Accardi, L.~T.~Brady, W.~Melnitchouk, J.~F.~Owens and N.~Sato,
   %``Constraints on large-$x$ parton distributions from new weak boson production and deep-inelastic scattering data,''
   arXiv:1602.03154 [hep-ph].
   %%CITATION = ARXIV:1602.03154;%%
 %\cite{Harland-Lang:2014zoa}
 \bibitem{Harland-Lang:2014zoa}
   L.~A.~Harland-Lang, A.~D.~Martin, P.~Motylinski and R.~S.~Thorne,
   %``Parton distributions in the LHC era: MMHT 2014 PDFs,''
   arXiv:1412.3989 [hep-ph].
   %%CITATION = ARXIV:1412.3989;%%
 %\cite{Dulat:2015mca}
 \bibitem{Dulat:2015mca}
   S.~Dulat {\it et al.},
   %``The CT14 Global Analysis of Quantum Chromodynamics,''
   arXiv:1506.07443 [hep-ph].
   %%CITATION = ARXIV:1506.07443;%%
 
 
 %\cite{Salam:2008qg}
 \bibitem{Salam:2008qg}
   G.~P.~Salam and J.~Rojo,
   {\em A Higher Order Perturbative Parton Evolution Toolkit (HOPPET)},
   Comput.\ Phys.\ Commun.\  {\bf 180}, 120 (2009)
   [arXiv:0804.3755 [hep-ph]].
   %%CITATION = ARXIV:0804.3755;%%
 
 %\cite{Kilian:2011ka}
 \bibitem{Kilian:2011ka}
   W.~Kilian, J.~Reuter, S.~Schmidt and D.~Wiesler,
   {\em An Analytic Initial-State Parton Shower},
   JHEP {\bf 1204} (2012) 013
   [arXiv:1112.1039 [hep-ph]].
   %%CITATION = ARXIV:1112.1039;%%
 
 %\cite{Staub:2008uz}
 \bibitem{Staub:2008uz}
   F.~Staub,
   {\em Sarah},
   arXiv:0806.0538 [hep-ph].
   %%CITATION = ARXIV:0806.0538;%%
 
 %\cite{Staub:2009bi}
 \bibitem{Staub:2009bi}
   F.~Staub,
   {\em From Superpotential to Model Files for FeynArts and
     CalcHep/CompHep},
   Comput.\ Phys.\ Commun.\  {\bf 181}, 1077 (2010)
   [arXiv:0909.2863 [hep-ph]].
   %%CITATION = ARXIV:0909.2863;%%
 
 %\cite{Staub:2010jh}
 \bibitem{Staub:2010jh}
   F.~Staub,
   {\em Automatic Calculation of supersymmetric Renormalization Group
     Equations and Self Energies},
   Comput.\ Phys.\ Commun.\  {\bf 182}, 808 (2011)
   [arXiv:1002.0840 [hep-ph]].
   %%CITATION = ARXIV:1002.0840;%%
 
 %\cite{Staub:2012pb}
 \bibitem{Staub:2012pb}
   F.~Staub,
   {\em SARAH 3.2: Dirac Gauginos, UFO output, and more},
   Computer Physics Communications {\bf 184}, pp. 1792 (2013)
   [Comput.\ Phys.\ Commun.\  {\bf 184}, 1792 (2013)]
   [arXiv:1207.0906 [hep-ph]].
   %%CITATION = ARXIV:1207.0906;%%
 
 %\cite{Staub:2013tta}
 \bibitem{Staub:2013tta}
   F.~Staub,
   {\em SARAH 4: A tool for (not only SUSY) model builders},
   Comput.\ Phys.\ Commun.\  {\bf 185}, 1773 (2014)
   [arXiv:1309.7223 [hep-ph]].
   %%CITATION = ARXIV:1309.7223;%%
 
 \bibitem{mathematica}
   \Mathematica\ is a registered trademark of Wolfram Research, Inc.,
   Champain, IL, USA.
 
 %\cite{Porod:2003um}
 \bibitem{Porod:2003um}
   W.~Porod,
   {\em SPheno, a program for calculating supersymmetric spectra, SUSY
     particle decays and SUSY particle production at e+ e- colliders},
   Comput.\ Phys.\ Commun.\  {\bf 153}, 275 (2003)
   [hep-ph/0301101].
   %%CITATION = HEP-PH/0301101;%%
 
 %\cite{Porod:2011nf}
 \bibitem{Porod:2011nf}
   W.~Porod and F.~Staub,
   {\em SPheno 3.1: Extensions including flavour, CP-phases and models
     beyond the MSSM},
   Comput.\ Phys.\ Commun.\  {\bf 183}, 2458 (2012)
   [arXiv:1104.1573 [hep-ph]].
   %%CITATION = ARXIV:1104.1573;%%
 
 %\cite{Staub:2011dp}
 \bibitem{Staub:2011dp}
   F.~Staub, T.~Ohl, W.~Porod and C.~Speckner,
   %``A Tool Box for Implementing Supersymmetric Models,''
   Comput.\ Phys.\ Commun.\  {\bf 183}, 2165 (2012)
   [arXiv:1109.5147 [hep-ph]].
   %%CITATION = ARXIV:1109.5147;%%
 
 %%%%% FeynRules %%%%%
 
 %\cite{Christensen:2008py}
 \bibitem{Christensen:2008py}
   N.~D.~Christensen and C.~Duhr,
   {\em FeynRules - Feynman rules made easy},
   Comput.\ Phys.\ Commun.\  {\bf 180}, 1614 (2009)
   [arXiv:0806.4194 [hep-ph]].
   %%CITATION = ARXIV:0806.4194;%%
 
 %\cite{Christensen:2009jx}
 \bibitem{Christensen:2009jx}
   N.~D.~Christensen, P.~de Aquino, C.~Degrande, C.~Duhr, B.~Fuks,
   M.~Herquet, F.~Maltoni and S.~Schumann,
   {\em A Comprehensive approach to new physics simulations},
   Eur.\ Phys.\ J.\ C {\bf 71}, 1541 (2011)
   [arXiv:0906.2474 [hep-ph]].
   %%CITATION = ARXIV:0906.2474;%%
 
 %\cite{Duhr:2011se}
 \bibitem{Duhr:2011se}
   C.~Duhr and B.~Fuks,
   %``A superspace module for the FeynRules package,''
   Comput.\ Phys.\ Commun.\  {\bf 182}, 2404 (2011)
   [arXiv:1102.4191 [hep-ph]].
   %%CITATION = ARXIV:1102.4191;%%
 
 %\cite{Christensen:2010wz}
 \bibitem{Christensen:2010wz}
   N.~D.~Christensen, C.~Duhr, B.~Fuks, J.~Reuter and C.~Speckner,
   {\em Introducing an interface between WHIZARD and FeynRules},
   Eur.\ Phys.\ J.\ C {\bf 72}, 1990 (2012)
   [arXiv:1010.3251 [hep-ph]].
   %%CITATION = ARXIV:1010.3251;%%
 
 %\cite{Degrande:2011ua}
 \bibitem{Degrande:2011ua}
   C.~Degrande, C.~Duhr, B.~Fuks, D.~Grellscheid, O.~Mattelaer and T.~Reiter,
   %``UFO - The Universal FeynRules Output,''
   Comput.\ Phys.\ Commun.\  {\bf 183}, 1201 (2012)
   doi:10.1016/j.cpc.2012.01.022
   [arXiv:1108.2040 [hep-ph]].
   %%CITATION = doi:10.1016/j.cpc.2012.01.022;%%
 
 %\cite{Han:1998sg}
 \bibitem{Han:1998sg}
   T.~Han, J.~D.~Lykken and R.~-J.~Zhang,
   {\em On Kaluza-Klein states from large extra dimensions},
   Phys.\ Rev.\ D {\bf 59}, 105006 (1999)
   [hep-ph/9811350].
   %%CITATION = HEP-PH/9811350;%%
 
 %\cite{Fuks:2012im}
 \bibitem{Fuks:2012im}
   B.~Fuks,
   {\em Beyond the Minimal Supersymmetric Standard Model: from theory
     to phenomenology},
   Int.\ J.\ Mod.\ Phys.\ A {\bf 27}, 1230007 (2012)
   [arXiv:1202.4769 [hep-ph]].
   %%CITATION = ARXIV:1202.4769;%%
 
 %\cite{He:2007ge}
 \bibitem{He:2007ge}
   H.~-J.~He, Y.~-P.~Kuang, Y.~-H.~Qi, B.~Zhang, A.~Belyaev,
   R.~S.~Chivukula, N.~D.~Christensen and A.~Pukhov {\it et al.},
   {\em CERN LHC Signatures of New Gauge Bosons in Minimal Higgsless
     Model},
   Phys.\ Rev.\ D {\bf 78}, 031701 (2008)
   [arXiv:0708.2588 [hep-ph]].
   %%CITATION = ARXIV:0708.2588;%%
 
 %%%%% WHIZARD NLO %%%%%
 
 %\cite{Kilian:2006cj}
 \bibitem{Kilian:2006cj}
   W.~Kilian, J.~Reuter and T.~Robens,
   {\em NLO Event Generation for Chargino Production at the ILC},
   Eur.\ Phys.\ J.\ C {\bf 48}, 389 (2006)
   [hep-ph/0607127].
   %%CITATION = HEP-PH/0607127;%%
 
 %\cite{Binoth:2010ra}
 \bibitem{Binoth:2010ra}
   J.~R.~Andersen {\it et al.}  [SM and NLO Multileg Working Group
   Collaboration],
   {\em Les Houches 2009: The SM and NLO Multileg Working Group:
     Summary report},
   arXiv:1003.1241 [hep-ph].
   %%CITATION = ARXIV:1003.1241;%%
 
 %\cite{Butterworth:2010ym}
 \bibitem{Butterworth:2010ym}
   J.~M.~Butterworth, A.~Arbey, L.~Basso, S.~Belov, A.~Bharucha,
   F.~Braam, A.~Buckley and M.~Campanelli {\it et al.},
   {\em Les Houches 2009: The Tools and Monte Carlo working group
     Summary Report},
   arXiv:1003.1643 [hep-ph], arXiv:1003.1643 [hep-ph].
   %%CITATION = ARXIV:1003.1643;%%
 
 %\cite{Binoth:2009rv}
 \bibitem{Binoth:2009rv}
   T.~Binoth, N.~Greiner, A.~Guffanti, J.~Reuter, J.-P.~.Guillet and T.~Reiter,
   {\em Next-to-leading order QCD corrections to pp --> b anti-b b
     anti-b + X at the LHC: the quark induced case},
   Phys.\ Lett.\ B {\bf 685}, 293 (2010)
   [arXiv:0910.4379 [hep-ph]].
   %%CITATION = ARXIV:0910.4379;%%
 
 %\cite{Greiner:2011mp}
 \bibitem{Greiner:2011mp}
   N.~Greiner, A.~Guffanti, T.~Reiter and J.~Reuter,
   {\em NLO QCD corrections to the production of two bottom-antibottom
     pairs at the LHC}
   Phys.\ Rev.\ Lett.\  {\bf 107}, 102002 (2011)
   [arXiv:1105.3624 [hep-ph]].
   %% CITATION = ARXIV:1105.3624;%%
 
 %\cite{L_Ecuyer:2002}
 \bibitem{L_Ecuyer:2002}
   P.~L\'{e}Ecuyer, R.~Simard, E.~J.~Chen, and W.~D.~Kelton,
   {\em An Object-Oriented Random-Number Package with Many Long Streams and
     Substreams}
   Operations Research, vol. 50, no. 6, pp. 1073-1075, Dec. 2002.
 
 \end{thebibliography}
 
 \end{document}
Index: trunk/tests/functional_tests/analyze_5.sh
===================================================================
--- trunk/tests/functional_tests/analyze_5.sh	(revision 0)
+++ trunk/tests/functional_tests/analyze_5.sh	(revision 8164)
@@ -0,0 +1,17 @@
+#!/bin/sh
+### Check WHIZARD for a simple test process
+name=`basename @script@`
+echo "Running script $0"
+if test -f OCAML_FLAG; then
+    ./run_whizard.sh @script@ --no-logging --no-model
+    echo "Contents of ${name}.debug" >> $name.log
+    cat ${name}.debug >> $name.log
+    echo "Contents of ${name}.dat" >> $name.log
+    cat ${name}.dat >> $name.log
+    diff ref-output/`basename @script@`.ref `basename @script@`.log
+else
+    echo "|=============================================================================|"
+    echo "No O'Mega matrix elements available, test skipped"
+    exit 77
+fi
+    
Index: trunk/tests/functional_tests/Makefile.am
===================================================================
--- trunk/tests/functional_tests/Makefile.am	(revision 8163)
+++ trunk/tests/functional_tests/Makefile.am	(revision 8164)
@@ -1,739 +1,740 @@
 ## Makefile.am -- Makefile for executable WHIZARD test scripts
 ##
 ## Process this file with automake to produce Makefile.in
 ##
 ########################################################################
 #
 # Copyright (C) 1999-2018 by
 #     Wolfgang Kilian <kilian@physik.uni-siegen.de>
 #     Thorsten Ohl <ohl@physik.uni-wuerzburg.de>
 #     Juergen Reuter <juergen.reuter@desy.de>
 #     with contributions from
 #     cf. main AUTHORS file
 #
 # WHIZARD is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2, or (at your option)
 # any later version.
 #
 # WHIZARD is distributed in the hope that it will be useful, but
 # WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 ########################################################################
 
 WHIZARD_DRIVER = run_whizard.sh
 
 TESTS_DEFAULT = \
     empty.run \
     fatal.run \
     structure_1.run \
     structure_2.run \
     structure_3.run \
     structure_4.run \
     structure_5.run \
     structure_6.run \
     structure_7.run \
     structure_8.run \
     vars.run \
     extpar.run \
     testproc_1.run \
     testproc_2.run \
     testproc_3.run \
     testproc_4.run \
     testproc_5.run \
     testproc_6.run \
     testproc_7.run \
     testproc_8.run \
     testproc_9.run \
     testproc_10.run \
     testproc_11.run \
     template_me_1.run \
     template_me_2.run \
     model_scheme_1.run \
     rebuild_1.run \
     rebuild_4.run \
     susyhit.run \
     helicity.run \
     libraries_4.run \
     job_id_1.run \
     pack_1.run
 
 XFAIL_TESTS_DEFAULT =
 
 TESTS_REQ_FASTJET = \
     analyze_4.run
 
 TESTS_REQ_OCAML = \
     libraries_1.run \
     libraries_2.run \
     libraries_3.run \
     rebuild_2.run \
     rebuild_3.run \
     rebuild_5.run \
     defaultcuts.run \
     cuts.run \
     model_change_1.run \
     model_change_2.run \
     model_test.run \
     job_id_2.run \
     job_id_3.run \
     job_id_4.run \
     qedtest_1.run \
     qedtest_2.run \
     qedtest_3.run \
     qedtest_4.run \
     qedtest_5.run \
     qedtest_6.run \
     qedtest_7.run \
     qedtest_8.run \
     qedtest_9.run \
     qedtest_10.run \
     beam_setup_1.run \
     beam_setup_2.run \
     beam_setup_3.run \
     beam_setup_4.run \
     beam_setup_5.run \
     qcdtest_1.run \
     qcdtest_2.run \
     qcdtest_3.run \
     qcdtest_4.run \
     qcdtest_5.run \
     qcdtest_6.run \
     observables_1.run \
     observables_2.run \
     event_weights_1.run \
     event_weights_2.run \
     event_eff_1.run \
     event_eff_2.run \
     event_dump_1.run \
     event_dump_2.run \
     reweight_1.run \
     reweight_2.run \
     reweight_3.run \
     reweight_4.run \
     reweight_5.run \
     reweight_6.run \
     reweight_7.run \
     reweight_8.run \
     analyze_1.run \
     analyze_2.run \
+    analyze_5.run \
     colors.run \
     colors_2.run \
     colors_hgg.run \
     alphas.run \
     jets_xsec.run \
     lhef_1.run \
     lhef_2.run \
     lhef_3.run \
     lhef_4.run \
     lhef_5.run \
     lhef_6.run \
     lhef_7.run \
     lhef_8.run \
     lhef_9.run \
     lhef_10.run \
     lhef_11.run \
     stdhep_1.run \
     stdhep_2.run \
     stdhep_3.run \
     stdhep_4.run \
     stdhep_5.run \
     stdhep_6.run \
     select_1.run \
     select_2.run \
     fatal_beam_decay.run \
     smtest_1.run \
     smtest_2.run \
     smtest_3.run \
     smtest_4.run \
     smtest_5.run \
     smtest_6.run \
     smtest_7.run \
     smtest_8.run \
     smtest_9.run \
     smtest_10.run \
     smtest_11.run \
     smtest_12.run \
     smtest_13.run \
     smtest_14.run \
     smtest_15.run \
     resonances_1.run \
     resonances_2.run \
     resonances_3.run \
     resonances_4.run \
     resonances_5.run \
     resonances_6.run \
     resonances_7.run \
     resonances_8.run \
     resonances_9.run \
     resonances_10.run \
     resonances_11.run \
     resonances_12.run \
     mssmtest_1.run \
     mssmtest_2.run \
     mssmtest_3.run \
     sm_cms_1.run \
     ufo_1.run \
     ufo_2.run \
     ufo_3.run \
     nlo_1.run \
     nlo_2.run \
     nlo_3.run \
     nlo_4.run \
     nlo_5.run \
     nlo_6.run \
     nlo_decay_1.run \
     real_partition_1.run \
     fks_res_1.run \
     fks_res_2.run \
     fks_res_3.run \
     openloops_1.run \
     openloops_2.run \
     openloops_3.run \
     openloops_4.run \
     openloops_5.run \
     openloops_6.run \
     openloops_7.run \
     openloops_8.run \
     openloops_9.run \
     openloops_10.run \
     recola_1.run \
     recola_2.run \
     recola_3.run \
     recola_4.run \
     recola_5.run \
     recola_6.run \
     recola_7.run \
     recola_8.run \
     powheg_1.run \
     spincor_1.run \
     show_1.run \
     show_2.run \
     show_3.run \
     show_4.run \
     show_5.run \
     method_ovm_1.run \
     multi_comp_1.run \
     multi_comp_2.run \
     multi_comp_3.run \
     multi_comp_4.run \
     flvsum_1.run \
     br_redef_1.run \
     decay_err_1.run \
     decay_err_2.run \
     decay_err_3.run \
     polarized_1.run \
     pdf_builtin.run \
     ep_1.run \
     ep_2.run \
     ep_3.run \
     circe1_1.run \
     circe1_2.run \
     circe1_3.run \
     circe1_4.run \
     circe1_5.run \
     circe1_6.run \
     circe1_7.run \
     circe1_8.run \
     circe1_9.run \
     circe1_10.run \
     circe1_photons_1.run \
     circe1_photons_2.run \
     circe1_photons_3.run \
     circe1_photons_4.run \
     circe1_photons_5.run \
     circe1_errors_1.run \
     circe2_1.run \
     circe2_2.run \
     circe2_3.run \
     ewa_1.run \
     ewa_2.run \
     ewa_3.run \
     ewa_4.run \
     isr_1.run \
     isr_2.run \
     isr_3.run \
     isr_4.run \
     isr_5.run \
     epa_1.run \
     epa_2.run \
     isr_epa_1.run \
     ilc.run \
     gaussian_1.run \
     gaussian_2.run \
     beam_events_1.run \
     beam_events_2.run \
     beam_events_3.run \
     beam_events_4.run \
     energy_scan_1.run \
     restrictions.run \
     process_log.run \
     shower_err_1.run \
     parton_shower_1.run \
     parton_shower_2.run \
     hadronize_1.run \
     mlm_matching_fsr.run \
     user_cuts.run \
     user_prc_threshold_1.run \
     cascades2_phs_1.run \
     user_prc_threshold_2.run
 
 XFAIL_TESTS_REQ_OCAML = \
     colors_hgg.run \
     hadronize_1.run \
     user_cuts.run
 
 TESTS_REQ_HEPMC = \
     hepmc_1.run \
     hepmc_2.run \
     hepmc_3.run \
     hepmc_4.run \
     hepmc_5.run \
     hepmc_6.run \
     hepmc_7.run \
     hepmc_8.run \
     hepmc_9.run \
     hepmc_10.run
 XFAIL_TESTS_REQ_HEPMC =
 
 TESTS_REQ_LCIO = \
     lcio_1.run \
     lcio_2.run \
     lcio_3.run \
     lcio_4.run \
     lcio_5.run
 XFAIL_TESTS_REQ_LCIO =
 
 TESTS_REQ_LHAPDF5 = \
     lhapdf5.run
 TESTS_REQ_LHAPDF6 = \
     lhapdf6.run
 XFAIL_TESTS_REQ_LHAPDF5 =
 XFAIL_TESTS_REQ_LHAPDF6 =
 
 TESTS_STATIC = \
     static_1.run \
     static_2.run
 XFAIL_TESTS_STATIC =
 
 TESTS_REQ_PYTHIA6 = \
     pythia6_1.run \
     pythia6_2.run \
     pythia6_3.run \
     pythia6_4.run \
     tauola_1.run \
     tauola_2.run \
     isr_5.run \
     mlm_pythia6_isr.run \
     mlm_matching_isr.run
 XFAIL_TESTS_REQ_PYTHIA6 =
 
 TESTS_REQ_EV_ANA = \
     analyze_3.run
 XFAIL_TESTS_REQ_EV_ANA =
 
 TESTS_REQ_GAMELAN = \
     analyze_3.run
 
 TEST_DRIVERS_RUN = \
     $(TESTS_DEFAULT) \
     $(TESTS_REQ_OCAML) \
     $(TESTS_REQ_LHAPDF5) \
     $(TESTS_REQ_LHAPDF6) \
     $(TESTS_REQ_HEPMC) \
     $(TESTS_REQ_LCIO) \
     $(TESTS_REQ_FASTJET) \
     $(TESTS_REQ_PYTHIA6) \
     $(TESTS_REQ_EV_ANA) \
     $(TESTS_STATIC)
 
 TEST_DRIVERS_SH = $(TEST_DRIVERS_RUN:.run=.sh)
 
 ########################################################################
 
 TESTS = 
 XFAIL_TESTS =
 TESTS_SRC =
 
 TESTS += $(TESTS_DEFAULT)
 XFAIL_TESTS += $(XFAIL_TESTS_DEFAULT)
 
 TESTS += $(TESTS_REQ_OCAML)
 XFAIL_TESTS += $(XFAIL_TESTS_REQ_OCAML)
 
 TESTS += $(TESTS_REQ_HEPMC)
 XFAIL_TESTS += $(XFAIL_TESTS_REQ_HEPMC)
 
 TESTS += $(TESTS_REQ_LCIO)
 XFAIL_TESTS += $(XFAIL_TESTS_REQ_LCIO)
 
 TESTS += $(TESTS_REQ_FASTJET)
 XFAIL_TESTS += $(XFAIL_TESTS_REQ_FASTJET)
 
 TESTS += $(TESTS_REQ_LHAPDF5)
 XFAIL_TESTS += $(XFAIL_TESTS_REQ_LHAPDF5)
 
 TESTS += $(TESTS_REQ_LHAPDF6)
 XFAIL_TESTS += $(XFAIL_TESTS_REQ_LHAPDF6)
 
 TESTS += $(TESTS_REQ_PYTHIA6)
 XFAIL_TESTS += $(XFAIL_TESTS_REQ_PYTHIA6)
 
 TESTS += $(TESTS_REQ_EV_ANA)
 XFAIL_TESTS += $(XFAIL_TESTS_REQ_EV_ANA)
 
 TESTS += $(TESTS_STATIC)
 XFAIL_TESTS += $(XFAIL_TESTS_STATIC)
 
 
 EXTRA_DIST = $(TEST_DRIVERS_SH) \
     $(TESTS_SRC)
 
 ########################################################################
 
 VPATH = $(srcdir)
 
 SUFFIXES = .sh .run
 
 .sh.run:
 	@rm -f $@
 	@if test -f $(top_builddir)/share/tests/functional_tests/$*.sin; then \
 		$(SED) 's|@script@|$(top_builddir)/share/tests/functional_tests/$*|g' $< > $@; \
 	elif test -f $(top_srcdir)/share/tests/functional_tests/$*.sin; then \
 		$(SED) 's|@script@|$(top_srcdir)/share/tests/functional_tests/$*|g' $< > $@; \
 	else \
 		echo "$*.sin not found!" 1>&2; \
 		exit 2; \
 	fi
 	@chmod +x $@
 
 structure_2.run: structure_2_inc.sin
 structure_2_inc.sin: $(top_builddir)/share/tests/functional_tests/structure_2_inc.sin
 	cp $< $@
 
 testproc_3.run: testproc_3.phs
 testproc_3.phs: $(top_builddir)/share/tests/functional_tests/testproc_3.phs
 	cp $< $@
 
 static_1.run: static_1.exe.sin
 static_1.exe.sin: $(top_builddir)/share/tests/functional_tests/static_1.exe.sin
 	cp $< $@
 static_2.run: static_2.exe.sin
 static_2.exe.sin: $(top_builddir)/share/tests/functional_tests/static_2.exe.sin
 	cp $< $@
 
 susyhit.run: susyhit.in
 user_cuts.run: user_cuts.f90
 user_cuts.f90: $(top_builddir)/share/tests/functional_tests/user_cuts.f90
 	cp $< $@
 
 model_test.run: tdefs.$(FC_MODULE_EXT) tglue.$(FC_MODULE_EXT) \
 	threeshl.$(FC_MODULE_EXT) tscript.$(FC_MODULE_EXT)
 tdefs.mod: $(top_builddir)/src/models/threeshl_bundle/tdefs.$(FC_MODULE_EXT)
 	cp $< $@
 tglue.mod: $(top_builddir)/src/models/threeshl_bundle/tglue.$(FC_MODULE_EXT)
 	cp $< $@
 tscript.mod: $(top_builddir)/src/models/threeshl_bundle/tscript.$(FC_MODULE_EXT)
 	cp $< $@
 threeshl.mod: $(top_builddir)/src/models/threeshl_bundle/threeshl.$(FC_MODULE_EXT)
 	cp $< $@
 
 WT_OCAML_NATIVE_EXT=opt
 
 if OCAML_AVAILABLE
 OMEGA_QED = $(top_builddir)/omega/bin/omega_QED.$(WT_OCAML_NATIVE_EXT)
 OMEGA_QCD = $(top_builddir)/omega/bin/omega_QCD.$(WT_OCAML_NATIVE_EXT)
 OMEGA_MSSM = $(top_builddir)/omega/bin/omega_MSSM.$(WT_OCAML_NATIVE_EXT)
 
 omega_MSSM.$(WT_OMEGA_CACHE_SUFFIX): $(OMEGA_MSSM)
 	$(OMEGA_MSSM) -initialize .
 
 UFO_TAG_FILE = __init__.py
 UFO_MODELPATH = ../models/UFO
 
 ufo_1.run: ufo_1_SM/$(UFO_TAG_FILE)
 ufo_2.run: ufo_2_SM/$(UFO_TAG_FILE)
 ufo_3.run: ufo_3_models/ufo_3_SM/$(UFO_TAG_FILE)
 
 ufo_1_SM/$(UFO_TAG_FILE): $(UFO_MODELPATH)/SM/$(UFO_TAG_FILE)
 	mkdir -p ufo_1_SM
 	cp $(UFO_MODELPATH)/SM/*.py ufo_1_SM
 ufo_2_SM/$(UFO_TAG_FILE): $(UFO_MODELPATH)/SM/$(UFO_TAG_FILE)
 	mkdir -p ufo_2_SM
 	cp $(UFO_MODELPATH)/SM/*.py ufo_2_SM
 ufo_3_models/ufo_3_SM/$(UFO_TAG_FILE): $(UFO_MODELPATH)/SM/$(UFO_TAG_FILE)
 	mkdir -p ufo_3_models/ufo_3_SM
 	cp $(UFO_MODELPATH)/SM/*.py ufo_3_models/ufo_3_SM
 
 $(UFO_MODELPATH)/SM/$(UFO_TAG_FILE): $(top_srcdir)/omega/tests/UFO/SM/$(UFO_TAG_FILE)
 	$(MAKE) -C $(UFO_MODELPATH)/SM all
 
 endif OCAML_AVAILABLE
 
 if MPOST_AVAILABLE
 $(TESTS_REQ_GAMELAN): gamelan.sty
 gamelan.sty: $(top_builddir)/src/gamelan/gamelan.sty
 	cp $< $@
 
 $(top_builddir)/src/gamelan/gamelan.sty:
 	$(MAKE) -C $(top_builddir)/src/gamelan gamelan.sty
 endif
 
 noinst_PROGRAMS = 
 
 if OCAML_AVAILABLE
 noinst_PROGRAMS += resonances_1_count
 resonances_1_count_SOURCES = resonances_1_count.f90
 resonances_1.run: resonances_1_count
 
 noinst_PROGRAMS += resonances_2_count
 resonances_2_count_SOURCES = resonances_2_count.f90
 resonances_2.run: resonances_2_count
 
 noinst_PROGRAMS += resonances_3_count
 resonances_3_count_SOURCES = resonances_3_count.f90
 resonances_3.run: resonances_3_count
 
 noinst_PROGRAMS += resonances_4_count
 resonances_4_count_SOURCES = resonances_4_count.f90
 resonances_4.run: resonances_4_count
 
 noinst_PROGRAMS += resonances_9_count
 resonances_9_count_SOURCES = resonances_9_count.f90
 resonances_9.run: resonances_9_count
 
 noinst_PROGRAMS += resonances_10_count
 resonances_10_count_SOURCES = resonances_10_count.f90
 resonances_10.run: resonances_10_count
 
 noinst_PROGRAMS += resonances_11_count
 resonances_11_count_SOURCES = resonances_11_count.f90
 resonances_11.run: resonances_11_count
 
 noinst_PROGRAMS += epa_2_count
 epa_2_count_SOURCES = epa_2_count.f90
 epa_2.run: epa_2_count
 
 noinst_PROGRAMS += isr_epa_1_count
 isr_epa_1_count_SOURCES = isr_epa_1_count.f90
 isr_epa_1.run: isr_epa_1_count
 
 endif
 
 if HEPMC_AVAILABLE
 TESTS_SRC += $(hepmc_6_rd_SOURCES)
 noinst_PROGRAMS += hepmc_6_rd
 if HEPMC_IS_VERSION3
 hepmc_6_rd_SOURCES = hepmc_6_v3_rd.cpp
 else
 hepmc_6_rd_SOURCES = hepmc_6_v2_rd.cpp
 endif
 hepmc_6_rd_CXXFLAGS = $(HEPMC_INCLUDES) $(AM_CXXFLAGS)
 hepmc_6_rd_LDADD = $(LDFLAGS_HEPMC)
 hepmc_6.run: hepmc_6_rd
 endif
 
 if LCIO_AVAILABLE
 TESTS_SRC += $(lcio_rd_SOURCES)
 noinst_PROGRAMS += lcio_rd
 lcio_rd_SOURCES = lcio_rd.cpp
 lcio_rd_CXXFLAGS = $(LCIO_INCLUDES) $(AM_CXXFLAGS)
 lcio_rd_LDADD = $(LDFLAGS_LCIO)
 lcio_1.run: lcio_rd
 lcio_2.run: lcio_rd
 lcio_3.run: lcio_rd
 lcio_4.run: lcio_rd
 lcio_5.run: lcio_rd
 endif
 
 stdhep_4.run: stdhep_rd
 stdhep_5.run: stdhep_rd
 stdhep_6.run: stdhep_rd
 polarized_1.run: stdhep_rd
 tauola_1.run: stdhep_rd
 tauola_2.run: stdhep_rd
 stdhep_rd: $(top_builddir)/src/xdr/stdhep_rd
 	cp $< $@
 
 susyhit.in: $(top_builddir)/share/tests/functional_tests/susyhit.in
 	cp $< $@
 
 BUILT_SOURCES = \
     TESTFLAG  \
     HEPMC_FLAG \
     LCIO_FLAG \
     FASTJET_FLAG \
     LHAPDF5_FLAG \
     LHAPDF6_FLAG \
     GAMELAN_FLAG \
     MPI_FLAG \
     EVENT_ANALYSIS_FLAG \
     OCAML_FLAG \
     PYTHIA6_FLAG \
     OPENLOOPS_FLAG \
     RECOLA_FLAG \
     GZIP_FLAG \
     STATIC_FLAG \
     ref-output
 
 # If this file is found in the working directory, WHIZARD
 # will use the paths for the uninstalled version (source/build tree),
 # otherwise it uses the installed version
 TESTFLAG:
 	touch $@
 
 FASTJET_FLAG:
 if FASTJET_AVAILABLE
 	touch $@
 endif
 
 HEPMC_FLAG:
 if HEPMC_AVAILABLE
 	touch $@
 endif
 
 LCIO_FLAG:
 if LCIO_AVAILABLE
 	touch $@
 endif
 
 LHAPDF5_FLAG:
 if LHAPDF5_AVAILABLE
 	touch $@
 endif
 
 LHAPDF6_FLAG:
 if LHAPDF6_AVAILABLE
 	touch $@
 endif
 
 GAMELAN_FLAG:
 if MPOST_AVAILABLE
 	touch $@
 endif
 
 MPI_FLAG:
 if FC_USE_MPI
 	touch $@
 endif
 
 OCAML_FLAG:
 if OCAML_AVAILABLE
 	touch $@
 endif
 
 PYTHIA6_FLAG:
 if PYTHIA6_AVAILABLE
 	touch $@
 endif
 
 OPENLOOPS_FLAG:
 if OPENLOOPS_AVAILABLE
 	touch $@
 endif
 
 RECOLA_FLAG:
 if RECOLA_AVAILABLE
 	touch $@
 endif
 
 EVENT_ANALYSIS_FLAG:
 if EVENT_ANALYSIS_AVAILABLE
 	touch $@
 endif
 
 GZIP_FLAG:
 if GZIP_AVAILABLE
 	touch $@
 endif
 
 STATIC_FLAG:
 if STATIC_AVAILABLE
 	touch $@
 endif
 
 # The reference output files are in the source directory.  Copy them here.
 if FC_QUAD
 ref-output: $(top_srcdir)/share/tests/functional_tests/ref-output
 	mkdir -p ref-output
 	for f in $</*.ref; do cp $$f $@; done
 	for f in $</../ref-output-prec/*.ref; do cp $$f $@; done
 	for f in $</../ref-output-quad/*.ref; do cp $$f $@; done
 else
 if FC_EXT
 ref-output: $(top_srcdir)/share/tests/functional_tests/ref-output
 	mkdir -p ref-output
 	for f in $</*.ref; do cp $$f $@; done
 	for f in $</../ref-output-prec/*.ref; do cp $$f $@; done
 	for f in $</../ref-output-ext/*.ref; do cp $$f $@; done
 else
 ref-output: $(top_srcdir)/share/tests/functional_tests/ref-output
 	mkdir -p ref-output
 	for f in $</*.ref; do cp $$f $@; done
 	for f in $</../ref-output-double/*.ref; do cp $$f $@; done
 endif
 endif
 
 ## installcheck runs the test scripts with the TESTFLAG removed.
 installcheck-local: notestflag check-am
 notestflag:
 	rm -f TESTFLAG
 .PHONY: notestflag
 
 ### Remove DWARF debug information on MAC OS X
 clean-macosx:
 	-rm -rf hepmc_6_rd.dSYM
 	-rm -rf lcio_rd.dSYM
 	-rm -rf static_1.exe.dSYM
 	-rm -rf static_2.exe.dSYM
 .PHONY: clean-macosx
 
 ## Remove generated files
 clean-local: clean-macosx
 	rm -f gamelan.sty
 	rm -f TESTFLAG GAMELAN_FLAG MPI_FLAG RECOLA_FLAG
 	rm -f OCAML_FLAG OPENLOOPS_FLAG FASTJET_FLAG HEPMC_FLAG LCIO_FLAG
 	rm -f EVENT_ANALYSIS_FLAG PYTHIA6_FLAG LHAPDF5_FLAG
 	rm -f LHAPDF6_FLAG 
 	rm -f GZIP_FLAG STATIC_FLAG static_1.exe static_2.exe
 	rm -f *.run *.log slha_test.out
 	rm -f core* stdhep_rd
 	rm -f *.f90 *.f90.in *.c *.$(FC_MODULE_EXT) *.o *.la
 	rm -f *_count.out
 	rm -f *.makefile
 	rm -f *.grid
 	rm -rf err-output
 	rm -rf ref-output
 	rm -f *.sin *.hbc *_fks_regions.out
 	rm -f *.olc *.olp *.olp_parameters output.rcl
 	rm -f *.phs *.vg *.vg2 *.pg *.vgb *.evt *.evx *.lhe *.hepmc *.dat *.debug *.fds
 	rm -f *.tmp *.hepevt *.hepevt.verb *.lha *.lha.verb *.slcio
 	rm -f prc_omega_diags_1_p_i1_diags.out prc_omega_diags_1_p_i1_diags.toc
 	rm -rf pack_1.1 pack_1.2 pack_1.3 pack_1.4
 	rm -rf pack_1.1.tgz pack_1.2.tgz pack_1.3.tgz pack_1.4.tgz
 	rm -f *.hep *.up.hep *.[1-9] *.[1-9][0-9] *.[1-9][0-9][0-9] 
 	rm -f *.tex *.mp *.mpx *.t[1-9] *.t[1-9][0-9] *.t[1-9][0-9][0-9] 
 	rm -f *.ltp *.aux *.dvi *.ps *.pdf so_test.*
 	rm -f *.tbl sps1ap_decays.slha bar structure_6[a-b].out 
 	rm -f slhaspectrum.in suspect2.out suspect2_lha.out 
 	rm -f susyhit.in susyhit_slha.out suspect2_lha.in
 	rm -rf job_id_3_x.8001 job_id_4_x.8001
 	rm -rf ufo_1_SM ufo_2_SM ufo_3_models
 	rm -f ufo_1_SM.ufo.mdl ufo_2_SM.ufo.mdl ufo_3_SM.ufo.mdl
 	rm -f *.$(WT_OMEGA_CACHE_SUFFIX)
 	rm -rf output_cll
 	rm -rf *.dSYM
 if FC_SUBMODULES
 	rm -f *.smod
 endif
 
 ## Remove backup files
 maintainer-clean-local: maintainer-clean-fc
 	-rm -f *~
 .PHONY: maintainer-clean-local