Index: trunk/src/transforms/transforms.nw =================================================================== --- trunk/src/transforms/transforms.nw (revision 8839) +++ trunk/src/transforms/transforms.nw (revision 8840) @@ -1,16339 +1,16345 @@ % -*- 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]]>>= <> module event_transforms <> <> use quantum_numbers, only: quantum_numbers_t use interactions use particles use model_data use rng_base use process, only: process_t use instances, only: process_instance_t use process_stacks <> <> <> <> interface <> end interface end module event_transforms @ %def event_transforms @ <<[[event_transforms_sub.f90]]>>= <> submodule (event_transforms) event_transforms_s use io_units use format_utils, only: write_separator use diagnostics use subevents implicit none contains <> end submodule event_transforms_s @ %def event_transforms_s @ \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 settings 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. <>= public :: evt_t <>= 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 () logical :: only_weighted_events = .false. contains <> 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. <>= procedure :: final => evt_final procedure :: base_final => evt_final <>= module subroutine evt_final (evt) class(evt_t), intent(inout) :: evt end subroutine evt_final <>= module 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]]. <>= procedure (evt_write_name), deferred :: write_name <>= 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 @ <>= procedure (evt_write), deferred :: write <>= 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. <>= procedure :: base_write => evt_base_write <>= module 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 end subroutine evt_base_write <>= module 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. <>= procedure :: connect => evt_connect procedure :: base_connect => evt_connect <>= module 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 end subroutine evt_connect <>= module 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. <>= procedure :: reset => evt_reset procedure :: base_reset => evt_reset <>= module subroutine evt_reset (evt) class(evt_t), intent(inout) :: evt end subroutine evt_reset <>= module 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. <>= procedure (evt_prepare_new_event), deferred :: prepare_new_event <>= 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. <>= procedure (evt_generate_weighted), deferred :: generate_weighted <>= 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. <>= procedure :: generate_unweighted => evt_generate_unweighted procedure :: base_generate_unweighted => evt_generate_unweighted <>= module subroutine evt_generate_unweighted (evt) class(evt_t), intent(inout) :: evt end subroutine evt_generate_unweighted <>= module 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. <>= procedure (evt_make_particle_set), deferred :: make_particle_set <>= 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. <>= procedure :: set_particle_set => evt_set_particle_set <>= module 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 end subroutine evt_set_particle_set <>= module 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, the [[int_matrix]], and one with the probability distributed among flows, the [[int_flows]]. We use the two values from the random number generator saved in [[r]] for factorizing the state. For testing purposes, we can provide those numbers explicitly. The optional [[qn_select]] allows to limit the number of quantum numbers to choose from when factorizing. If only a single set of quantum numbers is given, it effectively dictates the quantum numbers chosen for the event. <>= procedure :: factorize_interactions => evt_factorize_interactions <>= module 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 end subroutine evt_factorize_interactions <>= module 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 @ <>= public :: make_factorized_particle_set <>= module 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 end subroutine make_factorized_particle_set <>= module 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. <>= procedure :: tag_incoming => evt_tag_incoming <>= module subroutine evt_tag_incoming (evt) class(evt_t), intent(inout) :: evt end subroutine evt_tag_incoming <>= module 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. <>= public :: evt_trivial_t <>= type, extends (evt_t) :: evt_trivial_t contains <> end type evt_trivial_t @ %def evt_trivial_t @ <>= procedure :: write_name => evt_trivial_write_name <>= module subroutine evt_trivial_write_name (evt, unit) class(evt_trivial_t), intent(in) :: evt integer, intent(in), optional :: unit end subroutine evt_trivial_write_name <>= module 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: <>= procedure :: write => evt_trivial_write <>= module 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 end subroutine evt_trivial_write <>= module 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) !!! More readable but wider output; in line with evt_resonance_write ! if (verbose .and. 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_trivial_write @ %def evt_trivial_write @ Nothing to do here: <>= procedure :: prepare_new_event => evt_trivial_prepare_new_event <>= module 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 end subroutine evt_trivial_prepare_new_event <>= module 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. <>= procedure :: generate_weighted => evt_trivial_generate_weighted <>= module subroutine evt_trivial_generate_weighted (evt, probability) class(evt_trivial_t), intent(inout) :: evt real(default), intent(inout) :: probability end subroutine evt_trivial_generate_weighted <>= module 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. Note that it is a potential risk to tolerate a non-existent particle set at this point. We should remove it once the flavors are determined correctly in all cases. It is currently neccessary if we are keeping failed events [[?keep_failed_events = .true.]]. For these events, we do not compute the matrix elements, so the factorization fails trying to determine the quantum numbers. Additionally, it is necessary for the trivial event transformation preceeding the event transformations required for POWHEG matching. <>= procedure :: make_particle_set => evt_trivial_make_particle_set <>= module 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 end subroutine evt_trivial_make_particle_set <>= module 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]]>>= <> module event_transforms_ut use unit_tests use event_transforms_uti <> <> contains <> end module event_transforms_ut @ %def event_transforms_ut @ <<[[event_transforms_uti.f90]]>>= <> module event_transforms_uti <> <> use format_utils, only: write_separator use os_interface use sm_qcd use models 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 <> <> contains <> <> end module event_transforms_uti @ %def event_transforms_uti @ API: driver for the unit tests below. <>= public :: event_transforms_test <>= subroutine event_transforms_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> 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. <>= call test (event_transforms_1, "event_transforms_1", & "trivial event transform", & u, results) <>= public :: event_transforms_1 <>= subroutine event_transforms_1 (u) integer, intent(in) :: u type(os_data_t) :: os_data type(model_t), target :: model type(process_library_t), target :: lib type(string_t) :: libname, procname1 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 () libname = "event_transforms_1_lib" procname1 = "event_transforms_1_p" call prc_test_create_library (libname, lib, & scattering = .true., procname1 = procname1) call reset_interaction_counter () call model%init_test () allocate (process) call process%init (procname1, lib, os_data, model) call process%setup_test_cores () allocate (phs_single_config_t :: phs_config_template) call process%init_components (phs_config_template) sqrts = 1000 call process%setup_beams_sqrts (sqrts, i_core = 1) call process%configure_phs () call process%setup_mci (dispatch_mci_test_midpoint) 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) call evt%connect (process_instance, process%get_model_ptr ()) 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 @ MCI record prepared for midpoint integrator. <>= subroutine dispatch_mci_test_midpoint (mci, var_list, process_id, is_nlo) use variables, only: var_list_t class(mci_t), allocatable, intent(out) :: mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id logical, intent(in), optional :: is_nlo allocate (mci_midpoint_t :: mci) end subroutine dispatch_mci_test_midpoint @ %def dispatch_mci_test_midpoint @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{Hadronization interface} <<[[hadrons.f90]]>>= <> module hadrons <> <> use event_transforms use lorentz use model_data use models use particles use physics_defs use process, only: process_t use instances, only: process_instance_t use process_stacks use whizard_lha use pythia8 use rng_base, only: rng_t use shower_base use shower_pythia6 use sm_qcd use variables <> <> <> <> <> interface <> end interface end module hadrons @ %def hadrons @ <<[[hadrons_sub.f90]]>>= <> submodule (hadrons) hadrons_s <> use constants use diagnostics use format_utils, only: write_separator use helicities use hep_common use io_units use numeric_utils, only: vanishes use subevents implicit none contains <> end submodule hadrons_s @ %def hadrons_s @ \subsection{Hadronization implementations} <>= public :: HADRONS_UNDEFINED, HADRONS_WHIZARD, HADRONS_PYTHIA6, HADRONS_PYTHIA8 <>= 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 <>= public :: hadrons_method <>= interface hadrons_method module procedure hadrons_method_of_string module procedure hadrons_method_to_string end interface <>= elemental module function hadrons_method_of_string (string) result (i) integer :: i type(string_t), intent(in) :: string end function hadrons_method_of_string elemental module function hadrons_method_to_string (i) result (string) type(string_t) :: string integer, intent(in) :: i end function hadrons_method_to_string <>= elemental module 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 module 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. <>= public :: hadron_settings_t <>= type :: hadron_settings_t logical :: active = .false. integer :: method = HADRONS_UNDEFINED real(default) :: enhanced_fraction = 0 real(default) :: enhanced_width = 0 contains <> end type hadron_settings_t @ %def hadron_settings_t @ Read in the hadronization settings. <>= procedure :: init => hadron_settings_init <>= module subroutine hadron_settings_init (hadron_settings, var_list) class(hadron_settings_t), intent(out) :: hadron_settings type(var_list_t), intent(in) :: var_list end subroutine hadron_settings_init <>= module 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 @ <>= procedure :: write => hadron_settings_write <>= module subroutine hadron_settings_write (settings, unit) class(hadron_settings_t), intent(in) :: settings integer, intent(in), optional :: unit end subroutine hadron_settings_write <>= module 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 <>= 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 <> end type hadrons_t @ %def hadrons_t @ <>= procedure (hadrons_init), deferred :: init <>= 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 @ <>= procedure (hadrons_hadronize), deferred :: hadronize <>= 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 @ <>= procedure (hadrons_make_particle_set), deferred :: make_particle_set <>= 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 @ <>= procedure :: import_rng => hadrons_import_rng <>= pure module subroutine hadrons_import_rng (hadrons, rng) class(hadrons_t), intent(inout) :: hadrons class(rng_t), intent(inout), allocatable :: rng end subroutine hadrons_import_rng <>= pure module 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. <>= public :: hadrons_hadrons_t <>= type, extends (hadrons_t) :: hadrons_hadrons_t contains <> end type hadrons_hadrons_t @ %def hadrons_hadrons_t @ <>= procedure :: init => hadrons_hadrons_init <>= module 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 end subroutine hadrons_hadrons_init <>= module 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 @ <>= procedure :: hadronize => hadrons_hadrons_hadronize <>= module 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 end subroutine hadrons_hadrons_hadronize <>= module 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 if (debug_on) 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. <>= public :: had_flav_t <>= type had_flav_t end type had_flav_t @ %def had_flav_t @ This is the type for the ends of Lund strings. <>= public :: lund_end <>= 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. <>= public :: lund_pt_t <>= 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 <> end type lund_pt_t @ %def lund_pt <>= procedure :: init => lund_pt_init <>= module 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 <>= module 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 @ <>= procedure :: make_particle_set => hadrons_hadrons_make_particle_set <>= module 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 end subroutine hadrons_hadrons_make_particle_set <>= module 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 @ <>= 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. <>= public :: hadrons_pythia6_t <>= type, extends (hadrons_t) :: hadrons_pythia6_t contains <> end type hadrons_pythia6_t @ %def hadrons_pythia6_t <>= procedure :: init => hadrons_pythia6_init <>= module 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 end subroutine hadrons_pythia6_init <>= module 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. <>= procedure :: hadronize => hadrons_pythia6_hadronize <>= module 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 end subroutine hadrons_pythia6_hadronize <>= module 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 if (debug_on) 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 @ <>= procedure :: make_particle_set => hadrons_pythia6_make_particle_set <>= module 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 end subroutine hadrons_pythia6_make_particle_set <>= module 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} @ <>= public :: hadrons_pythia8_t <>= type, extends (hadrons_t) :: hadrons_pythia8_t type(pythia8_t) :: pythia type(whizard_lha_t) :: lhaup logical :: user_process_set = .false. logical :: pythia_initialized = .false., & lhaup_initialized = .false. contains <> end type hadrons_pythia8_t @ %def hadrons_pythia8_t @ <>= procedure :: init => hadrons_pythia8_init <>= module 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 end subroutine hadrons_pythia8_init <>= module 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 hadrons%model => model_hadrons hadrons%shower_settings = shower_settings hadrons%hadron_settings = hadron_settings call msg_message ("Hadronization: Using PYTHIA8 interface " // & "for hadronization and decays.") ! TODO sbrass which verbose? call hadrons%pythia%init (verbose = shower_settings%verbose) call hadrons%lhaup%init () end subroutine hadrons_pythia8_init @ %def hadrons_pythia8_init @ Transfer hadron settings to [[PYTHIA8]]. <>= procedure, private :: transfer_settings => hadrons_pythia8_transfer_settings <>= module subroutine hadrons_pythia8_transfer_settings (hadrons) class(hadrons_pythia8_t), intent(inout), target :: hadrons end subroutine hadrons_pythia8_transfer_settings <>= module subroutine hadrons_pythia8_transfer_settings (hadrons) class(hadrons_pythia8_t), intent(inout), target :: hadrons real(default) :: r if (debug_on) call msg_debug & (D_TRANSFORMS, "hadrons_pythia8_transfer_settings") if (debug_on) call msg_debug2 & (D_TRANSFORMS, "pythia_initialized", hadrons%pythia_initialized) if (hadrons%pythia_initialized) return call hadrons%pythia%import_rng (hadrons%rng) call hadrons%pythia%parse_and_set_config & (hadrons%shower_settings%pythia8_config) if (len (hadrons%shower_settings%pythia8_config_file) > 0) & call hadrons%pythia%read_file & (hadrons%shower_settings%pythia8_config_file) call hadrons%pythia%read_string (var_str ("Beams:frameType = 5")) call hadrons%pythia%read_string (var_str ("ProcessLevel:all = off")) if (.not. hadrons%shower_settings%verbose) then call hadrons%pythia%read_string (var_str ("Print:quiet = on")) end if call hadrons%pythia%set_lhaup_ptr (hadrons%lhaup) call hadrons%pythia%init_pythia () hadrons%pythia_initialized = .true. end subroutine hadrons_pythia8_transfer_settings @ %def hadrons_pythia8_transfer_settings @ Set user process for the LHA interface. <>= procedure, private :: set_user_process => hadrons_pythia8_set_user_process <>= module subroutine hadrons_pythia8_set_user_process (hadrons, pset) class(hadrons_pythia8_t), intent(inout) :: hadrons type(particle_set_t), intent(in) :: pset end subroutine hadrons_pythia8_set_user_process <>= module subroutine hadrons_pythia8_set_user_process (hadrons, pset) class(hadrons_pythia8_t), intent(inout) :: hadrons type(particle_set_t), intent(in) :: pset integer, dimension(2) :: beam_pdg real(default), dimension(2) :: beam_energy integer, parameter :: process_id = 0, n_processes = 0 if (debug_on) call msg_debug & (D_TRANSFORMS, "hadrons_pythia8_set_user_process") beam_pdg = [pset%prt(1)%get_pdg (), pset%prt(2)%get_pdg ()] beam_energy = [energy(pset%prt(1)%p), energy(pset%prt(2)%p)] call hadrons%lhaup%set_init (beam_pdg, beam_energy, & n_processes, unweighted = .false., negative_weights = .false.) call hadrons%lhaup%set_process_parameters (process_id = process_id, & cross_section = one, error = one) end subroutine hadrons_pythia8_set_user_process @ %def hadrons_pythia8_set_user_process @ Import particle set. <>= procedure, private :: import_particle_set => & hadrons_pythia8_import_particle_set <>= module subroutine hadrons_pythia8_import_particle_set & (hadrons, particle_set) class(hadrons_pythia8_t), target, intent(inout) :: hadrons type(particle_set_t), intent(in) :: particle_set end subroutine hadrons_pythia8_import_particle_set <>= module subroutine hadrons_pythia8_import_particle_set (hadrons, particle_set) class(hadrons_pythia8_t), target, intent(inout) :: hadrons type(particle_set_t), intent(in) :: particle_set type(particle_set_t) :: pset_reduced integer, parameter :: PROCESS_ID = 1 if (debug_on) call msg_debug & (D_TRANSFORMS, "hadrons_pythia8_import_particle_set") if (.not. hadrons%user_process_set) then call hadrons%set_user_process (particle_set) hadrons%user_process_set = .true. end if call hadrons%lhaup%set_event_process (process_id = PROCESS_ID, & scale = -one, alpha_qcd = -one, alpha_qed = -one, weight = -one) call hadrons%lhaup%set_event (process_id = PROCESS_ID, & particle_set = particle_set, polarization = .true.) if (debug_active (D_TRANSFORMS)) then call hadrons%lhaup%list_init () end if end subroutine hadrons_pythia8_import_particle_set @ %def hadrons_pythia8_import_particle_set @ <>= procedure :: hadronize => hadrons_pythia8_hadronize <>= module 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 end subroutine hadrons_pythia8_hadronize <>= module 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 if (signal_is_pending ()) return call hadrons%import_particle_set (particle_set) if (.not. hadrons%pythia_initialized) & call hadrons%transfer_settings () call hadrons%pythia%next (valid) if (debug_active (D_TRANSFORMS)) then call hadrons%pythia%list_event () call particle_set%write (summary=.true., compressed=.true.) end if end subroutine hadrons_pythia8_hadronize @ %def hadrons_pythia8_hadronize @ <>= procedure :: make_particle_set => hadrons_pythia8_make_particle_set <>= module 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 end subroutine hadrons_pythia8_make_particle_set <>= module 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 type(particle_t), dimension(:), allocatable :: beam if (debug_on) call msg_debug & (D_TRANSFORMS, "hadrons_pythia8_make_particle_set") if (signal_is_pending ()) return associate (settings => hadrons%shower_settings) if (debug_active (D_TRANSFORMS)) then call msg_debug (D_TRANSFORMS, 'Combine PYTHIA8 with particle set') call msg_debug (D_TRANSFORMS, 'Particle set before replacing') call particle_set%write (summary=.true., compressed=.true.) call hadrons%pythia%list_event () call msg_debug (D_TRANSFORMS, string = "settings%hadron_collision", & value = settings%hadron_collision) end if call hadrons%pythia%get_hadron_particles (& model, hadrons%model, particle_set, & helicity = PRT_DEFINITE_HELICITY) end associate if (debug_active (D_TRANSFORMS)) then print *, 'Particle set after replacing' call particle_set%write (summary=.true., compressed=.true.) end if 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]]. <>= public :: evt_hadrons_t <>= type, extends (evt_t) :: evt_hadrons_t class(hadrons_t), allocatable :: hadrons type(model_t), pointer :: model_hadrons => null() type(qcd_t) :: qcd logical :: is_first_event contains <> 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. <>= procedure :: init => evt_hadrons_init <>= module subroutine evt_hadrons_init (evt, model_hadrons) class(evt_hadrons_t), intent(out) :: evt type(model_t), intent(in), target :: model_hadrons end subroutine evt_hadrons_init <>= module 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 @ <>= procedure :: write_name => evt_hadrons_write_name <>= module subroutine evt_hadrons_write_name (evt, unit) class(evt_hadrons_t), intent(in) :: evt integer, intent(in), optional :: unit end subroutine evt_hadrons_write_name <>= module 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. <>= procedure :: write => evt_hadrons_write <>= module 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 end subroutine evt_hadrons_write <>= module 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 @ <>= procedure :: first_event => evt_hadrons_first_event <>= module subroutine evt_hadrons_first_event (evt) class(evt_hadrons_t), intent(inout) :: evt end subroutine evt_hadrons_first_event <>= module subroutine evt_hadrons_first_event (evt) class(evt_hadrons_t), intent(inout) :: evt if (debug_on) call msg_debug (D_TRANSFORMS, "evt_hadrons_first_event") associate (settings => evt%hadrons%shower_settings) settings%hadron_collision = .false. if (all (evt%particle_set%prt(1: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 settings%hadron_collision = .true. else call msg_fatal ("evt_hadrons didn't recognize beams setup") end if if (debug_on) 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. <>= procedure :: generate_weighted => evt_hadrons_generate_weighted <>= module subroutine evt_hadrons_generate_weighted (evt, probability) class(evt_hadrons_t), intent(inout) :: evt real(default), intent(inout) :: probability end subroutine evt_hadrons_generate_weighted <>= module 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. <>= procedure :: make_particle_set => evt_hadrons_make_particle_set <>= module 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 end subroutine evt_hadrons_make_particle_set <>= module 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 @ Connect the process with the hadrons object. <>= procedure :: connect => evt_hadrons_connect <>= module subroutine evt_hadrons_connect & (evt, process_instance, model, process_stack) class(evt_hadrons_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 end subroutine evt_hadrons_connect <>= module subroutine evt_hadrons_connect & (evt, process_instance, model, process_stack) class(evt_hadrons_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) end subroutine evt_hadrons_connect @ %def evt_hadrons_connect @ Create RNG instances, spawned by the process object. <>= procedure :: make_rng => evt_hadrons_make_rng <>= module 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 end subroutine evt_hadrons_make_rng <>= module 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 @ <>= procedure :: prepare_new_event => evt_hadrons_prepare_new_event <>= module 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 end subroutine evt_hadrons_prepare_new_event <>= module 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]]>>= <> module resonance_insertion <> <> use rng_base, only: rng_t use selectors, only: selector_t use particles, only: particle_t, particle_set_t use resonances, only: resonance_history_set_t use resonances, only: resonance_tree_t use instances, only: process_instance_ptr_t use event_transforms <> <> <> interface <> end interface end module resonance_insertion @ %def resonance_insertion @ <<[[resonance_insertion_sub.f90]]>>= <> submodule (resonance_insertion) resonance_insertion_s use io_units use format_utils, only: write_separator use format_defs, only: FMT_12 use interactions, only: interaction_t use subevents, only: PRT_RESONANT implicit none contains <> end submodule resonance_insertion_s @ %def resonance_insertion_s @ \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. <>= public :: evt_resonance_t <>= 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 <> end type evt_resonance_t @ %def evt_resonance_t <>= procedure :: write_name => evt_resonance_write_name <>= module subroutine evt_resonance_write_name (evt, unit) class(evt_resonance_t), intent(in) :: evt integer, intent(in), optional :: unit end subroutine evt_resonance_write_name <>= module 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. <>= procedure :: write => evt_resonance_write <>= module 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 end subroutine evt_resonance_write <>= module 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. <>= procedure :: set_resonance_data => evt_resonance_set_resonance_data <>= module 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 end subroutine evt_resonance_set_resonance_data <>= module 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. <>= procedure :: set_library => evt_resonance_set_library <>= module subroutine evt_resonance_set_library (evt, libname) class(evt_resonance_t), intent(inout) :: evt type(string_t), intent(in) :: libname end subroutine evt_resonance_set_library <>= module 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. <>= procedure :: set_subprocess_instances & => evt_resonance_set_subprocess_instances <>= module subroutine evt_resonance_set_subprocess_instances (evt, instance) class(evt_resonance_t), intent(inout) :: evt type(process_instance_ptr_t), dimension(:), intent(in) :: instance end subroutine evt_resonance_set_subprocess_instances <>= module 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. <>= procedure :: set_on_shell_limit => evt_resonance_set_on_shell_limit <>= module 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 end subroutine evt_resonance_set_on_shell_limit <>= module 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. <>= procedure :: set_on_shell_turnoff => evt_resonance_set_on_shell_turnoff <>= module 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 end subroutine evt_resonance_set_on_shell_turnoff <>= module 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. <>= procedure :: set_background_factor => evt_resonance_set_background_factor <>= module subroutine evt_resonance_set_background_factor & (evt, background_factor) class(evt_resonance_t), intent(inout) :: evt real(default), intent(in) :: background_factor end subroutine evt_resonance_set_background_factor <>= module 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. <>= procedure :: import_rng => evt_resonance_import_rng <>= module subroutine evt_resonance_import_rng (evt, rng) class(evt_resonance_t), intent(inout) :: evt class(rng_t), allocatable, intent(inout) :: rng end subroutine evt_resonance_import_rng <>= module 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. <>= procedure :: write_selector => evt_resonance_write_selector <>= module 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 end subroutine evt_resonance_write_selector <>= module 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). <>= procedure :: init_selector => evt_resonance_init_selector <>= module 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 end subroutine evt_resonance_init_selector <>= module 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. <>= procedure :: get_selector_weights => evt_resonance_get_selector_weights <>= module subroutine evt_resonance_get_selector_weights (evt, weight) class(evt_resonance_t), intent(in) :: evt real(default), dimension(0:), intent(out) :: weight end subroutine evt_resonance_get_selector_weights <>= module 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. <>= procedure :: fill_momenta => evt_resonance_fill_momenta <>= module subroutine evt_resonance_fill_momenta (evt) class(evt_resonance_t), intent(inout) :: evt end subroutine evt_resonance_fill_momenta <>= module 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. <>= procedure :: determine_on_shell_histories & => evt_resonance_determine_on_shell_histories <>= module subroutine evt_resonance_determine_on_shell_histories & (evt, index_array) class(evt_resonance_t), intent(in) :: evt integer, dimension(:), allocatable, intent(out) :: index_array end subroutine evt_resonance_determine_on_shell_histories <>= module 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. <>= procedure :: evaluate_subprocess => evt_resonance_evaluate_subprocess <>= module subroutine evt_resonance_evaluate_subprocess (evt, index_array) class(evt_resonance_t), intent(inout) :: evt integer, dimension(:), intent(in) :: index_array end subroutine evt_resonance_evaluate_subprocess <>= module 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. <>= procedure :: get_master_sqme => evt_resonance_get_master_sqme procedure :: get_subprocess_sqme => evt_resonance_get_subprocess_sqme <>= module function evt_resonance_get_master_sqme (evt) result (sqme) class(evt_resonance_t), intent(in) :: evt real(default) :: sqme end function evt_resonance_get_master_sqme module 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 end subroutine evt_resonance_get_subprocess_sqme <>= module 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 module 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. <>= procedure :: apply_turnoff_factor => evt_resonance_apply_turnoff_factor <>= module 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 end subroutine evt_resonance_apply_turnoff_factor <>= module 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. <>= procedure :: compute_probabilities => evt_resonance_compute_probabilities <>= module subroutine evt_resonance_compute_probabilities (evt) class(evt_resonance_t), intent(inout) :: evt end subroutine evt_resonance_compute_probabilities <>= module 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). <>= procedure :: select_component => evt_resonance_select_component <>= module subroutine evt_resonance_select_component (evt, i_component) class(evt_resonance_t), intent(inout) :: evt integer, intent(in) :: i_component end subroutine evt_resonance_select_component <>= module 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. <>= procedure :: find_prt_invalid_color => evt_resonance_find_prt_invalid_color <>= module 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 end subroutine evt_resonance_find_prt_invalid_color <>= module 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} <>= procedure :: prepare_new_event => evt_resonance_prepare_new_event <>= module 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 end subroutine evt_resonance_prepare_new_event <>= module 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. <>= procedure :: generate_weighted => evt_resonance_generate_weighted <>= module subroutine evt_resonance_generate_weighted (evt, probability) class(evt_resonance_t), intent(inout) :: evt real(default), intent(inout) :: probability end subroutine evt_resonance_generate_weighted <>= module subroutine evt_resonance_generate_weighted (evt, probability) class(evt_resonance_t), intent(inout) :: evt real(default), intent(inout) :: probability integer :: i_term call evt%fill_momenta () call evt%compute_probabilities () if (associated (evt%process_instance)) then i_term = evt%process_instance%get_first_active_i_term () if (evt%process_instance%term(i_term)%passed) then call evt%selector%generate (evt%rng, evt%selected_history) end if else call evt%selector%generate (evt%rng, evt%selected_history) end if 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. <>= procedure :: make_particle_set => evt_resonance_make_particle_set <>= module 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 end subroutine evt_resonance_make_particle_set <>= module 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]]>>= <> module resonance_insertion_ut use unit_tests use resonance_insertion_uti <> <> contains <> end module resonance_insertion_ut @ %def resonance_insertion_ut @ <<[[resonance_insertion_uti.f90]]>>= <> module resonance_insertion_uti <> <> 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 <> <> contains <> end module resonance_insertion_uti @ %def resonance_insertion_uti @ API: driver for the unit tests below. <>= public :: resonance_insertion_test <>= subroutine resonance_insertion_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> 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. <>= call test (resonance_insertion_1, "resonance_insertion_1", & "simple resonance insertion", & u, results) <>= public :: resonance_insertion_1 <>= 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 () 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. <>= call test (resonance_insertion_2, "resonance_insertion_2", & "resonance color mismatch", & u, results) <>= public :: resonance_insertion_2 <>= 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 () 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))$. <>= call test (resonance_insertion_3, "resonance_insertion_3", & "complex resonance history", & u, results) <>= public :: resonance_insertion_3 <>= 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 () 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. <>= call test (resonance_insertion_4, "resonance_insertion_4", & "resonance history selection", & u, results) <>= public :: resonance_insertion_4 <>= 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 () 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. <>= call test (resonance_insertion_5, "resonance_insertion_5", & "resonance history on/off", & u, results) <>= public :: resonance_insertion_5 <>= 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 () 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. <>= call test (resonance_insertion_6, "resonance_insertion_6", & "resonance insertion with beam structure", & u, results) <>= public :: resonance_insertion_6 <>= 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 () 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]]>>= <> module recoil_kinematics <> use lorentz, only: vector4_t use lorentz, only: vector4_null 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(**) use lorentz, only: lambda <> <> <> <> interface <> end interface end module recoil_kinematics @ %def recoil_kinematics @ <<[[recoil_kinematics_sub.f90]]>>= <> submodule (recoil_kinematics) recoil_kinematics_s use constants, only: twopi implicit none contains <> end submodule recoil_kinematics_s @ %def recoil_kinematics_s @ \subsection{$\phi$ sampler} This is trivial. Generate an azimuthal angle, given a $(0,1)$ RNG parameter. <>= 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$. <>= public :: generate_q2_recoil <>= elemental module 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 end subroutine generate_q2_recoil <>= elemental module 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. <>= 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$. <>= 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$. <>= 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. <>= 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. <>= 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. <>= 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. <>= public :: solve_recoil <>= module 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 end subroutine solve_recoil <>= module 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. <>= public :: recoil_momenta <>= module subroutine recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, mo, & km, qm, qo, ok) 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 real(default), dimension(2), intent(in) :: mo 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 end subroutine recoil_momenta <>= module subroutine recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, mo, & km, qm, qo, ok) 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 real(default), dimension(2), intent(in) :: mo 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 type(vector4_t), dimension(2) :: pm type(lorentz_transformation_t) :: lt real(default) :: sqsh real(default) :: po4, po2 real(default), dimension(2) :: p0, p3 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) po4 = lambda (sqsh**2, mo(1)**2, mo(2)**2) ok = po4 > 0 if (ok) then po2 = sqrt (po4)/4 p0 = sqrt (po2 + mo**2) p3 = [sqrt (po2), -sqrt (po2)] qo = lt * vector4_moving (p0, p3, 3) else qo = vector4_null end if 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. <>= public :: recoil_transformation <>= module 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 end subroutine recoil_transformation <>= module 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. <>= public :: initial_transformation <>= module 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 end subroutine initial_transformation <>= module 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. The [[mo]] masses are used for the on-shell projection of the partons after radiation. They may be equal to [[m]], or set to zero. If [[ok]] is false, the data point has failed and we should repeat the procedure for a new set of RNG parameters [[r]]. <>= public :: generate_recoil <>= module subroutine generate_recoil & (sqrts, q_max, m, mo, 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) :: mo 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 end subroutine generate_recoil <>= module subroutine generate_recoil & (sqrts, q_max, m, mo, 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) :: mo 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, mo, km, qm, qo, ok) end if end subroutine generate_recoil @ %def generate_recoil @ \subsection{Unit tests} Test module, followed by the corresponding implementation module. <<[[recoil_kinematics_ut.f90]]>>= <> module recoil_kinematics_ut use unit_tests use recoil_kinematics_uti <> <> contains <> end module recoil_kinematics_ut @ %def recoil_kinematics_ut @ <<[[recoil_kinematics_uti.f90]]>>= <> module recoil_kinematics_uti <> 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 <> <> contains <> end module recoil_kinematics_uti @ %def recoil_kinematics_uti @ API: driver for the unit tests below. <>= public :: recoil_kinematics_test <>= subroutine recoil_kinematics_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> 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. <>= call test (recoil_kinematics_1, "recoil_kinematics_1", & "iterative solution of non-collinear kinematics", & u, results) <>= public :: recoil_kinematics_1 <>= 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) :: mo 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 mo = 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, mo, 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 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, mo, km, qm, qo, ok) 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, mo, km, qm, qo, ok) 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, mo, km, qm, qo, ok) 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, mo, 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 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. <>= call test (recoil_kinematics_2, "recoil_kinematics_2", & "Q distribution", & u, results) <>= public :: recoil_kinematics_2 <>= 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. <>= call test (recoil_kinematics_3, "recoil_kinematics_3", & "generate recoil event", & u, results) <>= public :: recoil_kinematics_3 <>= subroutine recoil_kinematics_3 (u) integer, intent(in) :: u real(default) :: sqrts real(default), dimension(2) :: q_max real(default), dimension(2) :: m, mo 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 mo = 0 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, mo, 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, mo, 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, mo, 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. <>= call test (recoil_kinematics_4, "recoil_kinematics_4", & "reference frame", & u, results) <>= public :: recoil_kinematics_4 <>= 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) :: mo 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 mo = 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, mo, km, qm, qo, ok) 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, mo, km, qm, qo, ok) 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. <>= call test (recoil_kinematics_5, "recoil_kinematics_5", & "initial reference frame", & u, results) <>= public :: recoil_kinematics_5 <>= 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 @ \subsubsection{Transformation after recoil with on-shell momenta} Given a solution to recoil kinematics, compute the Lorentz transformation that transforms the old collinear parton momenta into the new parton momenta. Compare the results for massless and massive on-shell projection. <>= call test (recoil_kinematics_6, "recoil_kinematics_6", & "massless/massive on-shell projection", & u, results) <>= public :: recoil_kinematics_6 <>= subroutine recoil_kinematics_6 (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 real(default), dimension(2) :: mo, z 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,F11.6))" write (u, "(A)") "* Test output: recoil_kinematics_6" write (u, "(A)") "* Purpose: check effect of mass in on-shell projection" write (u, "(A)") sqrts = 10 write (u, FMT1) "sqrts =", sqrts z = 0 mo = 0.511e-3 write (u, FMT1) "mass =", mo 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, z, km, qm, qo, ok) call recoil_transformation (sqrts, xc, qo, lt) write (u, "(A)") write (u, "(A)") "Massless projection:" call show_momenta call recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, mo, km, qm, qo, ok) call recoil_transformation (sqrts, xc, qo, lt) write (u, "(A)") write (u, "(A)") "Massive projection:" 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 recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, z, km, qm, qo, ok) call recoil_transformation (sqrts, xc, qo, lt) write (u, "(A)") write (u, "(A)") "Massless projection:" call show_momenta call recoil_momenta (sqrts, xc, xb, cos_th, sin_th, phi, mo, km, qm, qo, ok) call recoil_transformation (sqrts, xc, qo, lt) write (u, "(A)") write (u, "(A)") "Massive projection:" call show_momenta write (u, "(A)") write (u, "(A)") "* Test output end: recoil_kinematics_6" 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_momenta write (u, "(A)") "Momenta: q(os)" call qo(1)%write (u, testflag=.true.) write (u, FMT2) "m = ", abs (qo(1)**1) call qo(2)%write (u, testflag=.true.) write (u, FMT2) "m = ", abs (qo(2)**1) end subroutine show_momenta end subroutine recoil_kinematics_6 @ %def recoil_kinematics_6 @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \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]]>>= <> module isr_epa_handler <> <> 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 flavors, only: flavor_t use particles, only: particle_t use rng_base, only: rng_t use event_transforms <> <> <> <> interface <> end interface end module isr_epa_handler @ %def isr_epa_handler @ <<[[isr_epa_handler_sub.f90]]>>= <> submodule (isr_epa_handler) isr_epa_handler_s 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 recoil_kinematics, only: initial_transformation use recoil_kinematics, only: generate_recoil use recoil_kinematics, only: recoil_transformation implicit none contains <> end submodule isr_epa_handler_s @ %def isr_epa_handler_s @ \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. <>= public :: evt_isr_epa_t <>= 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 logical :: isr_keep_mass = .true. 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 <> end type evt_isr_epa_t @ %def evt_isr_epa_t @ \subsection{ISR/EPA distinction} <>= 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 <>= 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} <>= integer, parameter, public :: ISR_TRIVIAL_COLLINEAR = 0 integer, parameter, public :: ISR_PAIR_RECOIL = 1 @ %def ISR_TRIVIAL_COLLINEAR ISR_PAIR_RECOIL @ <>= procedure :: get_mode_string => evt_isr_epa_get_mode_string <>= module function evt_isr_epa_get_mode_string (evt) result (string) type(string_t) :: string class(evt_isr_epa_t), intent(in) :: evt end function evt_isr_epa_get_mode_string <>= module 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. <>= procedure :: set_mode_string => evt_isr_epa_set_mode_string <>= module subroutine evt_isr_epa_set_mode_string (evt, string) class(evt_isr_epa_t), intent(inout) :: evt type(string_t), intent(in) :: string end subroutine evt_isr_epa_set_mode_string <>= module 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} <>= procedure :: write_name => evt_isr_epa_write_name <>= module subroutine evt_isr_epa_write_name (evt, unit) class(evt_isr_epa_t), intent(in) :: evt integer, intent(in), optional :: unit end subroutine evt_isr_epa_write_name <>= module 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. <>= procedure :: write_mode => evt_isr_epa_write_mode <>= module subroutine evt_isr_epa_write_mode (evt, unit) class(evt_isr_epa_t), intent(in) :: evt integer, intent(in), optional :: unit end subroutine evt_isr_epa_write_mode <>= module 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. <>= procedure :: write_input => evt_isr_epa_write_input <>= module 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 end subroutine evt_isr_epa_write_input <>= module 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 write (u, "(3x,A,1x,L1)") " keep m=", evt%isr_keep_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. <>= procedure :: write_data => evt_isr_epa_write_data <>= module 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 end subroutine evt_isr_epa_write_data <>= module 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. <>= procedure :: write => evt_isr_epa_write <>= module 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 end subroutine evt_isr_epa_write <>= module 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. <>= procedure :: import_rng => evt_isr_epa_import_rng <>= module subroutine evt_isr_epa_import_rng (evt, rng) class(evt_isr_epa_t), intent(inout) :: evt class(rng_t), allocatable, intent(inout) :: rng end subroutine evt_isr_epa_import_rng <>= module 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. <>= procedure :: set_data_isr => evt_isr_epa_set_data_isr <>= module subroutine evt_isr_epa_set_data_isr (evt, sqrts, q_max, m, keep_mass) class(evt_isr_epa_t), intent(inout) :: evt real(default), intent(in) :: sqrts real(default), intent(in) :: q_max real(default), intent(in) :: m logical, intent(in) :: keep_mass end subroutine evt_isr_epa_set_data_isr <>= module subroutine evt_isr_epa_set_data_isr (evt, sqrts, q_max, m, keep_mass) class(evt_isr_epa_t), intent(inout) :: evt real(default), intent(in) :: sqrts real(default), intent(in) :: q_max real(default), intent(in) :: m logical, intent(in) :: keep_mass 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. evt%isr_keep_mass = keep_mass 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. <>= procedure :: set_data_epa => evt_isr_epa_set_data_epa <>= module 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 end subroutine evt_isr_epa_set_data_epa <>= module 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. <>= procedure, private :: identify_radiated <>= module subroutine identify_radiated (evt) class(evt_isr_epa_t), intent(inout) :: evt end subroutine identify_radiated <>= module 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. <>= procedure, private :: identify_partons <>= module subroutine identify_partons (evt) class(evt_isr_epa_t), intent(inout) :: evt end subroutine identify_partons <>= module 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. <>= procedure :: check_radiation => evt_isr_epa_check_radiation <>= module subroutine evt_isr_epa_check_radiation (evt) class(evt_isr_epa_t), intent(inout) :: evt end subroutine evt_isr_epa_check_radiation <>= module 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. <>= procedure :: set_recoil_parameters => evt_isr_epa_set_recoil_parameters <>= module subroutine evt_isr_epa_set_recoil_parameters (evt) class(evt_isr_epa_t), intent(inout) :: evt end subroutine evt_isr_epa_set_recoil_parameters <>= module 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. <>= procedure, private :: boost_to_cm <>= module subroutine boost_to_cm (evt) class(evt_isr_epa_t), intent(inout) :: evt end subroutine boost_to_cm <>= module 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. <>= procedure, private :: infer_x <>= module subroutine infer_x (evt) class(evt_isr_epa_t), intent(inout) :: evt end subroutine infer_x <>= module 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. <>= procedure, private :: generate_recoil => evt_generate_recoil <>= module subroutine evt_generate_recoil (evt, ok) class(evt_isr_epa_t), intent(inout) :: evt logical, intent(out) :: ok end subroutine evt_generate_recoil <>= module 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, mo integer :: i call evt%rng%generate (r) m = 0 mo = 0 do i = 1, 2 select case (evt%rad_mode(i)) case (BEAM_RAD_ISR) m(i) = evt%m(i) if (evt%isr_keep_mass) mo(i) = m(i) case (BEAM_RAD_EPA) m(i) = evt%xc(i) * evt%m(i) end select end do call generate_recoil (evt%sqrts, evt%q_max, m, mo, 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. <>= procedure, private :: replace_radiated procedure, private :: replace_partons <>= module subroutine replace_radiated (evt) class(evt_isr_epa_t), intent(inout) :: evt end subroutine replace_radiated module subroutine replace_partons (evt) class(evt_isr_epa_t), intent(inout) :: evt end subroutine replace_partons <>= module 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 module 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. <>= procedure :: transform_outgoing => evt_transform_outgoing <>= module subroutine evt_transform_outgoing (evt) class(evt_isr_epa_t), intent(inout) :: evt end subroutine evt_transform_outgoing <>= module 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. <>= procedure :: generate_weighted => & evt_isr_epa_generate_weighted <>= module subroutine evt_isr_epa_generate_weighted (evt, probability) class(evt_isr_epa_t), intent(inout) :: evt real(default), intent(inout) :: probability end subroutine evt_isr_epa_generate_weighted <>= module 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. <>= procedure :: make_particle_set => & evt_isr_epa_make_particle_set <>= module 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 end subroutine evt_isr_epa_make_particle_set <>= module 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 @ <>= procedure :: prepare_new_event => & evt_isr_epa_prepare_new_event <>= module 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 end subroutine evt_isr_epa_prepare_new_event <>= module 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]]>>= <> module isr_epa_handler_ut use unit_tests use isr_epa_handler_uti <> <> contains <> end module isr_epa_handler_ut @ %def isr_epa_handler_ut @ <<[[isr_epa_handler_uti.f90]]>>= <> module isr_epa_handler_uti <> <> 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 particles, only: particle_set_t, pacify use event_transforms use isr_epa_handler, only: evt_isr_epa_t use rng_base_ut, only: rng_test_t <> <> contains <> end module isr_epa_handler_uti @ %def isr_epa_handler_uti @ API: driver for the unit tests below. <>= public :: isr_handler_test <>= subroutine isr_handler_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> 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. <>= call test (isr_handler_1, "isr_handler_1", & "collinear case, no modification", & u, results) <>= public :: isr_handler_1 <>= 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 () 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 pacify (evt_trivial%particle_set) 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). <>= call test (isr_handler_2, "isr_handler_2", & "two-photon recoil", & u, results) <>= public :: isr_handler_2 <>= 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 () 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 pacify (evt_trivial%particle_set) 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, & keep_mass = .false. & ) 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). <>= call test (isr_handler_3, "isr_handler_3", & "two-photon recoil with boost", & u, results) <>= public :: isr_handler_3 <>= 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 () 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 pacify (evt_trivial%particle_set) 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, & keep_mass = .false. & ) 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. <>= public :: epa_handler_test <>= subroutine epa_handler_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> 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. <>= call test (epa_handler_1, "epa_handler_1", & "collinear case, no modification", & u, results) <>= public :: epa_handler_1 <>= 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 () 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 pacify (evt_trivial%particle_set) 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). <>= call test (epa_handler_2, "epa_handler_2", & "two-beam recoil", & u, results) <>= public :: epa_handler_2 <>= 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 () 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 pacify (evt_trivial%particle_set) 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). <>= call test (epa_handler_3, "epa_handler_3", & "two-beam recoil with boost", & u, results) <>= public :: epa_handler_3 <>= 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 () 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 pacify (evt_trivial%particle_set) 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]]>>= <> module decays <> <> use diagnostics use flavors 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 <> <> <> <> interface <> end interface contains <> end module decays @ %def decays @ <<[[decays_sub.f90]]>>= <> submodule (decays) decays_s use io_units use format_utils, only: write_indent, write_separator use format_defs, only: FMT_15 use numeric_utils use helicities use quantum_numbers implicit none contains <> end submodule decays_s @ %def decays_s @ \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. <>= type, abstract :: any_config_t private contains <> end type any_config_t @ %def any_config_t @ Finalizer, depends on the implementation. <>= procedure (any_config_final), deferred :: final <>= 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: <>= procedure (any_config_write), deferred :: write <>= 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. <>= 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. <>= type, abstract :: any_t private contains <> end type any_t @ %def any_t @ Finalizer, depends on the implementation. <>= procedure (any_final), deferred :: final <>= 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: <>= procedure (any_write), deferred :: write <>= 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. <>= 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. <>= type :: decay_term_config_t private type(particle_config_t), dimension(:), allocatable :: prt contains <> end type decay_term_config_t @ %def decay_term_config_t @ Finalizer, recursive. <>= procedure :: final => decay_term_config_final <>= recursive module subroutine decay_term_config_final (object) class(decay_term_config_t), intent(inout) :: object end subroutine decay_term_config_final <>= recursive module 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 <>= procedure :: write => decay_term_config_write <>= recursive module 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 end subroutine decay_term_config_write <>= recursive module 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. Gfortran 7/8/9 bug, has to remain in the main module: <>= procedure :: init => decay_term_config_init <>= 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. <>= procedure :: compute => decay_term_config_compute <>= recursive module subroutine decay_term_config_compute (term) class(decay_term_config_t), intent(inout) :: term end subroutine decay_term_config_compute <>= recursive module 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. <>= type :: decay_term_t private type(decay_term_config_t), pointer :: config => null () type(particle_out_t), dimension(:), allocatable :: particle_out contains <> end type decay_term_t @ %def decay_term_t @ Finalizer. <>= procedure :: final => decay_term_final <>= recursive module subroutine decay_term_final (object) class(decay_term_t), intent(inout) :: object end subroutine decay_term_final <>= recursive module 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. <>= procedure :: write => decay_term_write <>= recursive module subroutine decay_term_write (object, unit, indent) class(decay_term_t), intent(in) :: object integer, intent(in), optional :: unit, indent end subroutine decay_term_write <>= recursive module 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. <>= procedure :: write_process_instances => decay_term_write_process_instances <>= recursive module 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 end subroutine decay_term_write_process_instances <>= recursive module 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. Gfortran 7/8/9 bug, has to remain in the main module: <>= procedure :: init => decay_term_init <>= 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. <>= procedure :: make_rng => decay_term_make_rng <>= module 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 end subroutine decay_term_make_rng <>= module 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. <>= procedure :: link_interactions => decay_term_link_interactions <>= recursive module subroutine decay_term_link_interactions (term, trace) class(decay_term_t), intent(inout) :: term type(interaction_t), intent(in), target :: trace end subroutine decay_term_link_interactions <>= recursive module 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. <>= procedure :: select_chain => decay_term_select_chain <>= recursive module subroutine decay_term_select_chain (term) class(decay_term_t), intent(inout) :: term end subroutine decay_term_select_chain <>= recursive module 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. <>= procedure :: generate => decay_term_generate <>= recursive module subroutine decay_term_generate (term) class(decay_term_t), intent(inout) :: term end subroutine decay_term_generate <>= recursive module 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. <>= public :: decay_root_config_t <>= 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 <> end type decay_root_config_t @ %def decay_root_config_t @ The finalizer is recursive since there may be cascade decays. <>= procedure :: final => decay_root_config_final <>= recursive module subroutine decay_root_config_final (object) class(decay_root_config_t), intent(inout) :: object end subroutine decay_root_config_final <>= recursive module 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. <>= procedure :: write => decay_root_config_write procedure :: write_header => decay_root_config_write_header procedure :: write_terms => decay_root_config_write_terms <>= recursive module 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 end subroutine decay_root_config_write module subroutine decay_root_config_write_header (object, unit, indent) class(decay_root_config_t), intent(in) :: object integer, intent(in), optional :: unit, indent end subroutine decay_root_config_write_header module 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 end subroutine decay_root_config_write_terms <>= recursive module 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 module 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 module 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. <>= procedure :: init => decay_root_config_init <>= module 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 end subroutine decay_root_config_init <>= module 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. <>= procedure :: init_term => decay_root_config_init_term <>= recursive module 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 end subroutine decay_root_config_init_term <>= recursive module 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. <>= procedure :: connect => decay_root_config_connect <>= recursive module 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 end subroutine decay_root_config_connect <>= recursive module 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 int%get_flv_out (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. <>= procedure :: compute => decay_root_config_compute <>= recursive module subroutine decay_root_config_compute (decay) class(decay_root_config_t), intent(inout) :: decay end subroutine decay_root_config_compute <>= recursive module 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. <>= 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 <> 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. <>= public :: decay_root_t <>= type, extends (decay_gen_t) :: decay_root_t private type(decay_root_config_t), pointer :: config => null () contains <> 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. <>= procedure :: base_final => decay_gen_final <>= recursive module subroutine decay_gen_final (object) class(decay_gen_t), intent(inout) :: object end subroutine decay_gen_final <>= recursive module 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. <>= procedure :: final => decay_root_final <>= module subroutine decay_root_final (object) class(decay_root_t), intent(inout) :: object end subroutine decay_root_final <>= module 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. <>= procedure :: write => decay_root_write <>= module subroutine decay_root_write (object, unit) class(decay_root_t), intent(in) :: object integer, intent(in), optional :: unit end subroutine decay_root_write <>= module 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. <>= procedure :: write_process_instances => decay_gen_write_process_instances <>= recursive module 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 end subroutine decay_gen_write_process_instances <>= recursive module 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. <>= procedure :: base_init => decay_gen_init <>= recursive module 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 end subroutine decay_gen_init <>= recursive module 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. <>= procedure :: init => decay_root_init <>= module 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 end subroutine decay_root_init <>= module 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.) <>= 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 <>= module subroutine decay_gen_set_mci (decay, i) class(decay_gen_t), intent(inout) :: decay integer, intent(in) :: i end subroutine decay_gen_set_mci module subroutine decay_gen_set_term (decay, i) class(decay_gen_t), intent(inout) :: decay integer, intent(in) :: i end subroutine decay_gen_set_term module function decay_gen_get_mci (decay) result (i) class(decay_gen_t), intent(inout) :: decay integer :: i end function decay_gen_get_mci module function decay_gen_get_term (decay) result (i) class(decay_gen_t), intent(inout) :: decay integer :: i end function decay_gen_get_term <>= module 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 module 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 module 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 module 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. <>= procedure :: make_term_rng => decay_gen_make_term_rng <>= module subroutine decay_gen_make_term_rng (decay, process) class(decay_gen_t), intent(inout) :: decay type(process_t), intent(in), pointer :: process end subroutine decay_gen_make_term_rng <>= module 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. <>= procedure :: link_term_interactions => decay_gen_link_term_interactions <>= recursive module subroutine decay_gen_link_term_interactions (decay) class(decay_gen_t), intent(inout) :: decay end subroutine decay_gen_link_term_interactions <>= recursive module subroutine decay_gen_link_term_interactions (decay) class(decay_gen_t), intent(inout) :: decay integer :: i type(interaction_t), pointer :: trace associate (instance => decay%process_instance) do i = 1, size (decay%term) trace => instance%get_trace_int_ptr (i) call decay%term(i)%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. <>= procedure :: select_chain => decay_root_select_chain <>= module subroutine decay_root_select_chain (decay_root) class(decay_root_t), intent(inout) :: decay_root end subroutine decay_root_select_chain <>= module 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. <>= procedure :: generate => decay_root_generate <>= module subroutine decay_root_generate (decay_root) class(decay_root_t), intent(inout) :: decay_root end subroutine decay_root_generate <>= module 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). <>= 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 <> end type decay_config_t @ %def decay_config_t @ The output routine extends the decay-root writer by listing numerical component values. <>= procedure :: write => decay_config_write <>= recursive module 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 end subroutine decay_config_write <>= recursive module 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. <>= procedure :: connect => decay_config_connect <>= recursive module 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 end subroutine decay_config_connect <>= recursive module 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%lab_is_cm ()) 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. <>= procedure :: set_flv => decay_config_set_flv <>= module subroutine decay_config_set_flv (decay, flv) class(decay_config_t), intent(inout) :: decay type(flavor_t), intent(in) :: flv end subroutine decay_config_set_flv <>= module 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. <>= procedure :: compute => decay_config_compute <>= recursive module subroutine decay_config_compute (decay) class(decay_config_t), intent(inout) :: decay end subroutine decay_config_compute <>= recursive module 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. <>= type, extends (decay_gen_t) :: decay_t private type(decay_config_t), pointer :: config => null () class(rng_t), allocatable :: rng contains <> end type decay_t @ %def decay_t @ The finalizer is recursive. <>= procedure :: final => decay_final <>= recursive module subroutine decay_final (object) class(decay_t), intent(inout) :: object end subroutine decay_final <>= recursive module 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. <>= procedure :: write => decay_write <>= recursive module subroutine decay_write (object, unit, indent, recursive) class(decay_t), intent(in) :: object integer, intent(in), optional :: unit, indent, recursive end subroutine decay_write <>= recursive module 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. <>= procedure :: init => decay_init <>= recursive module subroutine decay_init (decay, config) class(decay_t), intent(out) :: decay type(decay_config_t), intent(in), target :: config end subroutine decay_init <>= recursive module 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. <>= procedure :: link_interactions => decay_link_interactions <>= recursive module 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 end subroutine decay_link_interactions <>= recursive module 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. <>= procedure :: select_chain => decay_select_chain <>= recursive module subroutine decay_select_chain (decay) class(decay_t), intent(inout) :: decay end subroutine decay_select_chain <>= recursive module 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. <>= procedure :: generate => decay_generate <>= recursive module subroutine decay_generate (decay) class(decay_t), intent(inout) :: decay end subroutine decay_generate <>= recursive module 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). <>= type, extends (any_config_t) :: stable_config_t private type(flavor_t), dimension(:), allocatable :: flv contains <> end type stable_config_t @ %def stable_config_t @ The finalizer is empty: <>= procedure :: final => stable_config_final <>= module subroutine stable_config_final (object) class(stable_config_t), intent(inout) :: object end subroutine stable_config_final <>= module subroutine stable_config_final (object) class(stable_config_t), intent(inout) :: object end subroutine stable_config_final @ %def stable_config_final @ Output. <>= procedure :: write => stable_config_write <>= recursive module 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 end subroutine stable_config_write <>= recursive module 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. <>= procedure :: init => stable_config_init <>= module subroutine stable_config_init (config, flv) class(stable_config_t), intent(out) :: config type(flavor_t), dimension(:), intent(in) :: flv end subroutine stable_config_init <>= module 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. <>= type, extends (any_t) :: stable_t private type(stable_config_t), pointer :: config => null () contains <> end type stable_t @ %def stable_t @ The finalizer does nothing. <>= procedure :: final => stable_final <>= module subroutine stable_final (object) class(stable_t), intent(inout) :: object end subroutine stable_final <>= module 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. <>= procedure :: write => stable_write <>= module subroutine stable_write (object, unit, indent) class(stable_t), intent(in) :: object integer, intent(in), optional :: unit, indent end subroutine stable_write <>= module 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. <>= procedure :: init => stable_init <>= module subroutine stable_init (stable, config) class(stable_t), intent(out) :: stable type(stable_config_t), intent(in), target :: config end subroutine stable_init <>= module 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. <>= public :: unstable_config_t <>= 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 <> end type unstable_config_t @ %def unstable_config_t @ Finalizer. The branching configuration can be a recursive structure. <>= procedure :: final => unstable_config_final <>= recursive module subroutine unstable_config_final (object) class(unstable_config_t), intent(inout) :: object end subroutine unstable_config_final <>= recursive module 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. <>= procedure :: write => unstable_config_write <>= recursive module 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 end subroutine unstable_config_write <>= recursive module 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. <>= procedure :: init => unstable_config_init <>= module 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 end subroutine unstable_config_init <>= module 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. <>= procedure :: init_decays => unstable_config_init_decays <>= recursive module 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 end subroutine unstable_config_init_decays <>= recursive module 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_decays @ Explicitly connect a specific decay with a process. This is used only in unit tests. <>= procedure :: connect_decay => unstable_config_connect_decay <>= module 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 end subroutine unstable_config_connect_decay <>= module 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. <>= procedure :: compute => unstable_config_compute <>= recursive module subroutine unstable_config_compute (unstable) class(unstable_config_t), intent(inout) :: unstable end subroutine unstable_config_compute <>= recursive module 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. <>= public :: unstable_t <>= 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 <> end type unstable_t @ %def unstable_t @ Recursive finalizer. <>= procedure :: final => unstable_final <>= recursive module subroutine unstable_final (object) class(unstable_t), intent(inout) :: object end subroutine unstable_final <>= recursive module 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. <>= procedure :: write => unstable_write <>= recursive module subroutine unstable_write (object, unit, indent) class(unstable_t), intent(in) :: object integer, intent(in), optional :: unit, indent end subroutine unstable_write <>= recursive module 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. <>= procedure :: write_process_instances => unstable_write_process_instances <>= recursive module subroutine unstable_write_process_instances & (unstable, unit, verbose) class(unstable_t), intent(in) :: unstable integer, intent(in), optional :: unit logical, intent(in), optional :: verbose end subroutine unstable_write_process_instances <>= recursive module 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. <>= procedure :: init => unstable_init <>= recursive module subroutine unstable_init (unstable, config) class(unstable_t), intent(out) :: unstable type(unstable_config_t), intent(in), target :: config end subroutine unstable_init <>= recursive module 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. <>= procedure :: link_interactions => unstable_link_interactions <>= recursive module 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 end subroutine unstable_link_interactions <>= recursive module 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. <>= procedure :: import_rng => unstable_import_rng <>= module subroutine unstable_import_rng (unstable, rng) class(unstable_t), intent(inout) :: unstable class(rng_t), intent(inout), allocatable :: rng end subroutine unstable_import_rng <>= module 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. <>= procedure :: select_chain => unstable_select_chain <>= recursive module subroutine unstable_select_chain (unstable) class(unstable_t), intent(inout) :: unstable end subroutine unstable_select_chain <>= recursive module 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. <>= procedure :: generate => unstable_generate <>= recursive module subroutine unstable_generate (unstable) class(unstable_t), intent(inout) :: unstable end subroutine unstable_generate <>= recursive module 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: <>= 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. <>= public :: decay_chain_t <>= 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 <> end type decay_chain_t @ %def decay_chain_t @ The finalizer recursively deletes and deallocates the entries. <>= procedure :: final => decay_chain_final <>= module subroutine decay_chain_final (object) class(decay_chain_t), intent(inout) :: object end subroutine decay_chain_final <>= module 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. <>= procedure :: write => decay_chain_write <>= module subroutine decay_chain_write (object, unit) class(decay_chain_t), intent(in) :: object integer, intent(in), optional :: unit end subroutine decay_chain_write <>= module 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. <>= procedure :: build => decay_chain_build <>= module subroutine decay_chain_build (chain, decay_root) class(decay_chain_t), intent(inout), target :: chain type(decay_root_t), intent(in) :: decay_root end subroutine decay_chain_build <>= module 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. <>= procedure :: build_term_entries => decay_chain_build_term_entries <>= recursive module subroutine decay_chain_build_term_entries (chain, term) class(decay_chain_t), intent(inout) :: chain type(decay_term_t), intent(in) :: term end subroutine decay_chain_build_term_entries <>= recursive module 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. <>= procedure :: build_decay_entries => decay_chain_build_decay_entries <>= recursive module subroutine decay_chain_build_decay_entries (chain, decay) class(decay_chain_t), intent(inout) :: chain type(decay_t), intent(in) :: decay end subroutine decay_chain_build_decay_entries <>= recursive module 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). <>= procedure :: evaluate => decay_chain_evaluate <>= module subroutine decay_chain_evaluate (chain) class(decay_chain_t), intent(inout) :: chain end subroutine decay_chain_evaluate <>= module 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. <>= procedure :: get_probability => decay_chain_get_probability <>= module function decay_chain_get_probability (chain) result (x) class(decay_chain_t), intent(in) :: chain real(default) :: x end function decay_chain_get_probability <>= module 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. <>= public :: evt_decay_t <>= 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 <> end type evt_decay_t @ %def evt_decay_t @ <>= procedure :: write_name => evt_decay_write_name <>= module subroutine evt_decay_write_name (evt, unit) class(evt_decay_t), intent(in) :: evt integer, intent(in), optional :: unit end subroutine evt_decay_write_name <>= module 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. <>= procedure :: write => evt_decay_write <>= module 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 end subroutine evt_decay_write <>= module 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. <>= procedure :: set_var_list => evt_decay_set_var_list <>= module 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 end subroutine evt_decay_set_var_list <>= module 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. <>= procedure :: connect => evt_decay_connect <>= module 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 end subroutine evt_decay_connect <>= module 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. <>= procedure :: prepare_new_event => evt_decay_prepare_new_event <>= module 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 end subroutine evt_decay_prepare_new_event <>= module 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. <>= procedure :: generate_weighted => evt_decay_generate_weighted <>= module subroutine evt_decay_generate_weighted (evt, probability) class(evt_decay_t), intent(inout) :: evt real(default), intent(inout) :: probability end subroutine evt_decay_generate_weighted <>= module 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. <>= procedure :: make_particle_set => evt_decay_make_particle_set <>= module 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 end subroutine evt_decay_make_particle_set <>= module 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. <>= public :: pacify <>= interface pacify module procedure pacify_decay module procedure pacify_decay_gen module procedure pacify_term module procedure pacify_unstable end interface pacify <>= module subroutine pacify_decay (evt) class(evt_decay_t), intent(inout) :: evt end subroutine pacify_decay recursive module subroutine pacify_decay_gen (decay) class(decay_gen_t), intent(inout) :: decay end subroutine pacify_decay_gen recursive module subroutine pacify_term (term) class(decay_term_t), intent(inout) :: term end subroutine pacify_term recursive module subroutine pacify_unstable (unstable) class(unstable_t), intent(inout) :: unstable end subroutine pacify_unstable <>= module subroutine pacify_decay (evt) class(evt_decay_t), intent(inout) :: evt call pacify_decay_gen (evt%decay_root) end subroutine pacify_decay recursive module 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 module 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 module 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. <>= procedure :: init_test_case1 procedure :: init_test_case2 <>= module 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 end subroutine init_test_case1 module 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 end subroutine init_test_case2 <>= module 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 module 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]]>>= <> module decays_ut use unit_tests use decays_uti <> <> <> contains <> end module decays_ut @ %def decays_ut @ <<[[decays_uti.f90]]>>= <> module decays_uti <> <> use os_interface use sm_qcd use model_data use models 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 <> <> <> contains <> <> end module decays_uti @ %def decays_uti @ API: driver for the unit tests below. <>= public :: decays_test <>= subroutine decays_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> 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. <>= public :: prepare_testbed <>= 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_t), target :: model type(model_t), target :: model_copy type(string_t) :: libname, procname1, procname2 type(process_entry_t), pointer :: process type(process_instance_t), allocatable, target :: process_instance 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" 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 (phs_single_config_t :: phs_config_template) if (scattering) then 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, lib, os_data, model_copy) call process%setup_test_cores () call process%init_components (phs_config_template) sqrts = 1000 call process%setup_beams_sqrts (sqrts, i_core = 1) call process%configure_phs () call process%setup_mci (dispatch_mci_test_midpoint) 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 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, lib, os_data, model_copy) call process%setup_test_cores () call process%init_components (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 (dispatch_mci_test_midpoint) 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 () call model_copy%final () end subroutine prepare_testbed @ %def prepare_testbed @ MCI record prepared for midpoint integrator. <>= subroutine dispatch_mci_test_midpoint (mci, var_list, process_id, is_nlo) use variables, only: var_list_t class(mci_t), allocatable, intent(out) :: mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id logical, intent(in), optional :: is_nlo allocate (mci_midpoint_t :: mci) end subroutine dispatch_mci_test_midpoint @ %def dispatch_mci_test_midpoint @ \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. <>= call test (decays_1, "decays_1", & "branching and decay configuration", & u, results) <>= public :: decays_1 <>= 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 () 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. <>= call test (decays_2, "decays_2", & "cascade decay configuration", & u, results) <>= public :: decays_2 <>= 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 () 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. <>= call test (decays_3, "decays_3", & "associate process", & u, results) <>= public :: decays_3 <>= 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 () 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. <>= call test (decays_4, "decays_4", & "decay instance", & u, results) <>= public :: decays_4 <>= 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 () 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$. <>= call test (decays_5, "decays_5", & "parent process and decay", & u, results) <>= public :: decays_5 <>= 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 () 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_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$. <>= call test (decays_6, "decays_6", & "evt_decay object", & u, results) <>= public :: decays_6 <>= 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 () 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]]>>= <> module tau_decays <> use sm_qcd use model_data use models use event_transforms <> <> <> interface <> end interface end module tau_decays @ <<[[tau_decays_sub.f90]]>>= <> submodule (tau_decays) tau_decays_s use io_units use format_utils, only: write_separator implicit none contains <> end submodule tau_decays_s @ %def tau_decays_s @ @ %def tau_decays \subsection{Tau Decays Event Transform} This is the type for the tau decay event transform. <>= public :: evt_tau_decays_t <>= type, extends (evt_t) :: evt_tau_decays_t type(model_t), pointer :: model_hadrons => null() type(qcd_t) :: qcd contains <> end type evt_tau_decays_t @ %def evt_tau_decays_t <>= procedure :: write_name => evt_tau_decays_write_name <>= module subroutine evt_tau_decays_write_name (evt, unit) class(evt_tau_decays_t), intent(in) :: evt integer, intent(in), optional :: unit end subroutine evt_tau_decays_write_name <>= module 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. <>= procedure :: write => evt_tau_decays_write <>= module 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 end subroutine evt_tau_decays_write <>= module 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? <>= procedure :: generate_weighted => evt_tau_decays_generate_weighted <>= module subroutine evt_tau_decays_generate_weighted (evt, probability) class(evt_tau_decays_t), intent(inout) :: evt real(default), intent(inout) :: probability end subroutine evt_tau_decays_generate_weighted <>= module 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. <>= procedure :: make_particle_set => evt_tau_decays_make_particle_set <>= module 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 end subroutine evt_tau_decays_make_particle_set <>= module 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 @ <>= procedure :: prepare_new_event => evt_tau_decays_prepare_new_event <>= module 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 end subroutine evt_tau_decays_prepare_new_event <>= module 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]]>>= <> module shower <> <> use os_interface use pdf use shower_base use matching_base use sm_qcd use model_data use event_transforms use models use process, only: process_t use instances, only: process_instance_t use process_stacks <> <> <> <> interface <> end interface end module shower @ %def shower @ <<[[shower_sub.f90]]>>= <> submodule (shower) shower_s <> use io_units use format_utils, only: write_separator use system_defs, only: LF use diagnostics use lorentz use subevents, only: PRT_BEAM_REMNANT, PRT_INCOMING, PRT_OUTGOING use powheg_matching, only: powheg_matching_t use rng_base use hep_common implicit none contains <> end submodule shower_s @ %def shower_s @ \subsection{Configuration Parameters} [[POWHEG_TESTING]] allows to disable the parton shower for validation and testing of the POWHEG procedure. <>= logical, parameter :: POWHEG_TESTING = .true. @ %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. <>= public :: evt_shower_t <>= 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) :: qcd type(pdf_data_t) :: pdf_data type(os_data_t) :: os_data logical :: is_first_event contains <> end type evt_shower_t @ %def evt_shower_t @ <>= procedure :: write_name => evt_shower_write_name <>= module subroutine evt_shower_write_name (evt, unit) class(evt_shower_t), intent(in) :: evt integer, intent(in), optional :: unit end subroutine evt_shower_write_name <>= module 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. <>= procedure :: write => evt_shower_write <>= module 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 end subroutine evt_shower_write <>= module 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 <>= procedure :: connect => evt_shower_connect <>= module 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 end subroutine evt_shower_connect <>= module 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. <>= procedure :: init => evt_shower_init <>= module 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 end subroutine evt_shower_init <>= module 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. <>= procedure :: make_rng => evt_shower_make_rng <>= module subroutine evt_shower_make_rng (evt, process) class(evt_shower_t), intent(inout) :: evt type(process_t), intent(inout) :: process end subroutine evt_shower_make_rng <>= module 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. <>= procedure :: prepare_new_event => evt_shower_prepare_new_event <>= module 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 end subroutine evt_shower_prepare_new_event <>= module 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 real(default) :: fac_scale, alpha_s fac_scale = evt%process_instance%get_fac_scale (i_term) alpha_s = evt%process_instance%get_alpha_s (i_term) call evt%reset () call evt%shower%prepare_new_event (fac_scale, alpha_s) end subroutine evt_shower_prepare_new_event @ %def evt_shower_prepare_new_event @ <>= procedure :: first_event => evt_shower_first_event <>= module subroutine evt_shower_first_event (evt) class(evt_shower_t), intent(inout) :: evt end subroutine evt_shower_first_event <>= module subroutine evt_shower_first_event (evt) class(evt_shower_t), intent(inout) :: evt double precision :: pdftest if (debug_on) 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 if (debug_on) 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. <>= procedure :: generate_weighted => evt_shower_generate_weighted <>= module subroutine evt_shower_generate_weighted (evt, probability) class(evt_shower_t), intent(inout) :: evt real(default), intent(inout) :: probability end subroutine evt_shower_generate_weighted <>= module subroutine evt_shower_generate_weighted (evt, probability) class(evt_shower_t), intent(inout) :: evt real(default), intent(inout) :: probability logical :: valid, vetoed, is_powheg_matching if (debug_on) call msg_debug (D_TRANSFORMS, "evt_shower_generate_weighted") if (signal_is_pending ()) return evt%particle_set = evt%previous%particle_set valid = .true.; vetoed = .false.; is_powheg_matching = .false. if (evt%is_first_event) call evt%first_event () call evt%shower%import_particle_set (evt%particle_set) if (allocated (evt%matching)) then call evt%matching%before_shower (evt%particle_set, vetoed) if (msg_level(D_TRANSFORMS) >= DEBUG) then if (debug_on) call msg_debug & (D_TRANSFORMS, "Matching before generate emissions") call evt%matching%write () end if end if if (allocated (evt%matching)) then select type (matching => evt%matching) type is (powheg_matching_t) is_powheg_matching = .true. end select end if if (.not. vetoed) then if (.not. POWHEG_TESTING .or. .not. is_powheg_matching) 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 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. <>= procedure :: make_particle_set => evt_shower_make_particle_set <>= module 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 end subroutine evt_shower_make_particle_set <>= module 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 @ <>= procedure :: contains_powheg_matching => evt_shower_contains_powheg_matching <>= module function evt_shower_contains_powheg_matching (evt) result (val) logical :: val class(evt_shower_t), intent(in) :: evt end function evt_shower_contains_powheg_matching <>= module 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 @ <>= procedure :: disable_powheg_matching => evt_shower_disable_powheg_matching <>= module subroutine evt_shower_disable_powheg_matching (evt) class(evt_shower_t), intent(inout) :: evt end subroutine evt_shower_disable_powheg_matching <>= module 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 @ <>= procedure :: enable_powheg_matching => evt_shower_enable_powheg_matching <>= module subroutine evt_shower_enable_powheg_matching (evt) class(evt_shower_t), intent(inout) :: evt end subroutine evt_shower_enable_powheg_matching <>= module 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 @ <>= procedure :: final => evt_shower_final <>= module subroutine evt_shower_final (evt) class(evt_shower_t), intent(inout) :: evt end subroutine evt_shower_final <>= module 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]]>>= <> module shower_ut use unit_tests use shower_uti <> <> contains <> end module shower_ut @ %def shower_ut @ <<[[shower_uti.f90]]>>= <> module shower_uti <> <> use format_utils, only: write_separator use os_interface use sm_qcd use physics_defs, only: BORN use model_data use models use state_matrices, only: FM_IGNORE_HELICITY use process_libraries use rng_base use rng_tao use dispatch_rng, only: dispatch_rng_factory_fallback use mci_base use mci_midpoint use phs_base use phs_single use prc_core_def, only: prc_core_def_t use prc_core use prc_omega use variables 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 dispatch_rng_ut, only: dispatch_rng_factory_tao use shower <> <> contains <> end module shower_uti @ %def shower_uti @ API: driver for the unit tests below. <>= public :: shower_test <>= subroutine shower_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> end subroutine shower_test @ %def shower_test @ \subsubsection{Testbed} This sequence sets up a two-jet process, ready for generating events. <>= <> @ <>= 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 type(model_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 type(process_def_entry_t), pointer :: entry type(string_t), dimension(:), allocatable :: prt_in, prt_out class(prc_core_t), allocatable :: core_template class(phs_config_t), allocatable :: phs_config_template real(default) :: sqrts model_name = "SM" libname = prefix // "_lib" procname = prefix // "p" call os_data%init () dispatch_rng_factory_fallback => dispatch_rng_factory_tao 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, lib, os_data, model) allocate (prc_omega_t :: core_template) allocate (phs_single_config_t :: phs_config_template) call process%setup_cores (dispatch_core_omega_test) call process%init_components (phs_config_template) sqrts = 1000 call process%setup_beams_sqrts (sqrts, i_core = 1) call process%configure_phs () call process%setup_mci (dispatch_mci_test_midpoint) 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 @ A minimal dispatcher version that allocates the core object for testing. <>= subroutine dispatch_core_omega_test (core, core_def, model, & helicity_selection, qcd, use_color_factors, has_beam_pol) class(prc_core_t), allocatable, intent(inout) :: core class(prc_core_def_t), intent(in) :: core_def class(model_data_t), intent(in), target, optional :: model type(helicity_selection_t), intent(in), optional :: helicity_selection type(qcd_t), intent(in), optional :: qcd logical, intent(in), optional :: use_color_factors logical, intent(in), optional :: has_beam_pol allocate (prc_omega_t :: core) select type (core) type is (prc_omega_t) call core%set_parameters (model) end select end subroutine dispatch_core_omega_test @ %def dispatch_core_omega_test @ MCI record prepared for midpoint integrator. <>= subroutine dispatch_mci_test_midpoint (mci, var_list, process_id, is_nlo) use variables, only: var_list_t class(mci_t), allocatable, intent(out) :: mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id logical, intent(in), optional :: is_nlo allocate (mci_midpoint_t :: mci) end subroutine dispatch_mci_test_midpoint @ %def dispatch_mci_test_midpoint @ \subsubsection{Trivial Test} We generate a two-jet event and shower it using default settings, i.e. in disabled mode. <>= call test (shower_1, "shower_1", & "disabled shower", & u, results) <>= public :: shower_1 <>= 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 () 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, os_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. <>= call test (shower_2, "shower_2", & "final-state shower", & u, results) <>= public :: shower_2 <>= 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 () 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, os_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]]>>= <> module evt_nlo <> <> use constants use phs_points, only: phs_point_t use phs_points, only: assignment(=), operator(*), size use sm_qcd use model_data use particles use instances, only: process_instance_t use process_stacks use event_transforms use quantum_numbers, only: quantum_numbers_t 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 <> <> <> <> interface <> end interface end module evt_nlo @ %def evt_nlo @ <<[[evt_nlo_sub.f90]]>>= <> submodule (evt_nlo) evt_nlo_s <> use io_units, only: given_output_unit use diagnostics use format_utils, only: write_separator use numeric_utils, only: nearly_equal use physics_defs, only: BORN, NLO_REAL use lorentz use interactions, only: interaction_t use pcm, only: pcm_nlo_t, pcm_nlo_workspace_t use prc_core, only: prc_core_t use prc_external, only: prc_external_t use phs_fks, only: SQRTS_FIXED, SQRTS_VAR implicit none contains <> end submodule evt_nlo_s @ %def evt_nlo_s @ <>= type :: nlo_event_deps_t logical :: lab_is_cm = .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, virtual, subtraction and, if present, also DGLAP 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. As the NLO event transforms have different kinematics, they also differ in their [[particle_set]]s. The NLO [[event_t]] object carries a single pointer to a [[particle_set]]. To avoid interference between the different NLO [[particle_set]]s, we save the [[particle_set]] of the current $\alpha$-region in the array [[particle_set_nlo]]. Otherwise it would be unretrievable if the usual particle set of the event object was used. <>= 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 <>= public :: evt_nlo_t <>= type, extends (evt_t) :: evt_nlo_t type(phs_fks_generator_t) :: phs_fks_generator real(default) :: sqme_rad = zero integer :: i_evaluation = 0 type(particle_set_t), dimension(:), allocatable :: particle_set_nlo type(qcd_t) :: qcd 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 <> end type evt_nlo_t @ %def evt_nlo_t @ <>= procedure :: write_name => evt_nlo_write_name <>= module subroutine evt_nlo_write_name (evt, unit) class(evt_nlo_t), intent(in) :: evt integer, intent(in), optional :: unit end subroutine evt_nlo_write_name <>= module 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 @ <>= procedure :: write => evt_nlo_write <>= module 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 <>= module 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 integer :: u, i 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 = .true.) write (u,'(A,ES16.9)') "sqme_rad = ", evt%sqme_rad write (u, "(3x,A,I0)") "i_evaluation = ", evt%i_evaluation call write_separator (u) write (u, "(1x,A)") "Radiated particle sets:" do i = 1, size (evt%particle_set_nlo) call evt%particle_set_nlo(i)%write (u, testflag = testflag) call write_separator (u) end do 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]]. <>= procedure :: connect => evt_nlo_connect <>= module 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 end subroutine evt_nlo_connect <>= module 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 if (debug_on) call msg_debug (D_TRANSFORMS, "evt_nlo_connect") call evt%base_connect (process_instance, model, process_stack) select type (pcm_work => process_instance%pcm_work) class is (pcm_nlo_workspace_t) select type (pcm => process_instance%pcm) type is (pcm_nlo_t) call pcm%setup_phs_generator (pcm_work, evt%phs_fks_generator, & process_instance%get_sqrts ()) call evt%set_i_evaluation_mappings (pcm%region_data, & pcm_work%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) if (debug_on) call msg_debug2 (D_TRANSFORMS, "evt_nlo_connect: success") end subroutine evt_nlo_connect @ %def evt_nlo_connect @ <>= procedure :: set_i_evaluation_mappings => evt_nlo_set_i_evaluation_mappings <>= module 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 end subroutine evt_nlo_set_i_evaluation_mappings <>= type :: registered_triple_t integer, dimension(2) :: phs_em type(registered_triple_t), pointer :: next => null () end type registered_triple_t <>= module 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), allocatable, target :: check_list i_evaluation = 1 n_phs = reg_data%n_phs 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%kin(i_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 @ <>= procedure :: get_i_phs => evt_nlo_get_i_phs <>= module function evt_nlo_get_i_phs (evt) result (i_phs) integer :: i_phs class(evt_nlo_t), intent(in) :: evt end function evt_nlo_get_i_phs <>= module 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 @ <>= procedure :: get_emitter => evt_nlo_get_emitter <>= module function evt_nlo_get_emitter (evt) result (emitter) integer :: emitter class(evt_nlo_t), intent(in) :: evt end function evt_nlo_get_emitter <>= module 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 @ <>= procedure :: get_i_term => evt_nlo_get_i_term <>= module function evt_nlo_get_i_term (evt) result (i_term) integer :: i_term class(evt_nlo_t), intent(in) :: evt end function evt_nlo_get_i_term <>= module 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 @ The event transform has a variable which counts the number of times it has already been called for one generation point. If this variable, [[i_evaluation]], is zero, this means that [[evt_nlo_generate_weighted]] 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. During a separate integration of the real component, the first event of each event group will become the counterevent. In this case, we return the sum of all subtraction matrix elements. During a combined integration, the first event will be a combination of all Born-like events. To get the sum of their matrix elements, we subtract the sum of all real emissions from the sum of all matrix elements as the real contribution is the only non-Born contribution. Note that the argument named [[probablity]], the use of the routine [[generate_weighted]] and the procedure we use to generate NLO events via an event transformation is an abuse of the interface which should be refactored. <>= procedure :: generate_weighted => evt_nlo_generate_weighted <>= module subroutine evt_nlo_generate_weighted (evt, probability) class(evt_nlo_t), intent(inout) :: evt real(default), intent(inout) :: probability end subroutine evt_nlo_generate_weighted <>= module subroutine evt_nlo_generate_weighted (evt, probability) class(evt_nlo_t), intent(inout) :: evt real(default), intent(inout) :: probability real(default) :: sqme call print_debug_info () sqme = probability if (evt%mode > EVT_NLO_SEPARATE_BORNLIKE) then if (evt%i_evaluation == 0) then call evt%reset_phs_identifiers () call evt%evaluate_real_kinematics () if (evt%mode == EVT_NLO_SEPARATE_REAL) then sqme = evt%compute_subtraction_sqmes () else sqme = sqme - evt%compute_all_sqme_rad () end if else call evt%compute_real () sqme = evt%sqme_rad end if end if probability = sqme if (debug_on) call msg_debug & (D_TRANSFORMS, "probability (after)", probability) 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 () if (debug_on) call msg_debug (D_TRANSFORMS, "evt_nlo_generate_weighted") if (debug_on) call msg_debug & (D_TRANSFORMS, char ("mode: " // status_code_to_string (evt%mode))) if (debug_on) call msg_debug & (D_TRANSFORMS, "probability (before)", probability) if (debug_on) 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 @ <>= procedure :: reset_phs_identifiers => evt_nlo_reset_phs_identifiers <>= module subroutine evt_nlo_reset_phs_identifiers (evt) class(evt_nlo_t), intent(inout) :: evt end subroutine evt_nlo_reset_phs_identifiers <>= module 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 @ The routine [[make_factorized_particle_set]] will setup the subevent momenta from the [[connected%matrix]]. Its initial state momenta correspond to the Born process without IS splitting and thus need to be updated with the real momenta from the [[int_hard]] to get correct momenta in the events with real radiation. Ideally the [[int_hard]] and the [[connected]] would be setup with correct [[source_link]]s to real momenta so that we would not need to replace momenta of the [[connected]] here. The parameter [[n_in]] from the [[int_matrix]] is still $0$ as it has been shifted to [[n_vir]]. We thus take [[n_in]] from the [[particle_set]]. <>= procedure :: connected_set_real_IS_momenta => & evt_nlo_connected_set_real_IS_momenta <>= module subroutine evt_nlo_connected_set_real_IS_momenta (evt) class(evt_nlo_t), intent(inout) :: evt end subroutine evt_nlo_connected_set_real_IS_momenta <>= module subroutine evt_nlo_connected_set_real_IS_momenta (evt) class(evt_nlo_t), intent(inout) :: evt type(vector4_t) :: p_hard, p_beam, p_remn type(interaction_t), pointer :: int_matrix integer :: i, i_term, n_in, i_in_beam, i_in_hard, i_in_remn i_term = evt%get_i_term () int_matrix => evt%process_instance%get_matrix_int_ptr (i_term) n_in = evt%particle_set%get_n_in () do i = 1, n_in i_in_beam = i i_in_hard = n_in + i i_in_remn = 2 * n_in + i p_hard = evt%process_instance%term(i_term)%int_hard%get_momentum (i) p_beam = int_matrix%get_momentum (i_in_beam) p_remn = p_beam - p_hard call int_matrix%set_momentum (p_hard , i_in_hard) call int_matrix%set_momentum (p_remn , i_in_remn) end do end subroutine evt_nlo_connected_set_real_IS_momenta @ %def evt_nlo_connected_set_real_IS_momenta @ <>= procedure :: make_particle_set => evt_nlo_make_particle_set <>= module 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 end subroutine evt_nlo_make_particle_set <>= module 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 call make_factorized_particle_set (evt, factorization_mode, & keep_correlations, r, evt%get_i_term (), & evt%get_selected_quantum_numbers (evt%selected_i_flv)) 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 @ <>= procedure :: evaluate_real_kinematics => evt_nlo_evaluate_real_kinematics <>= module subroutine evt_nlo_evaluate_real_kinematics (evt) class(evt_nlo_t), intent(inout) :: evt end subroutine evt_nlo_evaluate_real_kinematics <>= module 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 :: n_regions integer :: i_term type(vector4_t), dimension(:), allocatable :: p_real select type (pcm_work => evt%process_instance%pcm_work) class is (pcm_nlo_workspace_t) x_rad = pcm_work%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)%p_seed 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) select type (pcm => evt%process_instance%pcm) type is (pcm_nlo_t) n_regions = pcm%region_data%n_regions end select do alr = 1, n_regions i_phs = pcm_work%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) if (emitter <= evt%process%get_n_in ()) then call generator%prepare_generation (x_rad, i_phs, emitter, & event_deps%p_born_cms%phs_point(1)%get (), & event_deps%phs_identifiers) ! TODO wk 19-02-28: intent of p_real (also below)? p_real = event_deps%p_real_lab%phs_point(i_phs) select case (generator%isr_kinematics%isr_mode) case (SQRTS_FIXED) call generator%generate_isr_fixed_beam_energy (i_phs, & event_deps%p_born_cms%phs_point(1)%get (), & p_real) case (SQRTS_VAR) call generator%generate_isr (i_phs, & event_deps%p_born_lab%phs_point(1)%get (), & p_real) end select event_deps%p_real_lab%phs_point(i_phs) = p_real 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)%get (), & event_deps%phs_identifiers, event_deps%contributors, i_con) p_real = event_deps%p_real_cms%phs_point(i_phs) call generator%generate_fsr (emitter, i_phs, i_con, & event_deps%p_born_cms%phs_point(1)%get (), & p_real) event_deps%p_real_cms%phs_point(i_phs) = p_real else call generator%prepare_generation (x_rad, i_phs, emitter, & event_deps%p_born_cms%phs_point(1)%get (), & event_deps%phs_identifiers) p_real = event_deps%p_real_cms%phs_point(i_phs) call generator%generate_fsr (emitter, i_phs, & event_deps%p_born_cms%phs_point(1)%get (), & p_real) event_deps%p_real_cms%phs_point(i_phs) = p_real 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_work%set_momenta & (event_deps%p_born_lab%phs_point(1)%get (), & event_deps%p_real_lab%phs_point(i_phs)%get (), & i_phs) call pcm_work%set_momenta & (event_deps%p_born_cms%phs_point(1)%get (), & event_deps%p_real_cms%phs_point(i_phs)%get (), & 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. <>= procedure :: compute_subtraction_sqmes => evt_nlo_compute_subtraction_sqmes <>= module function evt_nlo_compute_subtraction_sqmes (evt) result (sqme) class(evt_nlo_t), intent(inout) :: evt real(default) :: sqme end function evt_nlo_compute_subtraction_sqmes <>= module function evt_nlo_compute_subtraction_sqmes (evt) result (sqme) class(evt_nlo_t), intent(inout) :: evt real(default) :: sqme integer :: i_phs, i_term if (debug_on) call msg_debug & (D_TRANSFORMS, "evt_nlo_compute_subtraction_sqmes") sqme = zero 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, is_subtraction = .true.) sqme = sqme + evt%process_instance%get_sqme (i_term) end associate end function evt_nlo_compute_subtraction_sqmes @ %def evt_nlo_compute_subtraction_sqmes @ This routine calls the evaluation of the singular regions only for emission matrix elements. <>= procedure :: compute_real => evt_nlo_compute_real <>= module subroutine evt_nlo_compute_real (evt) class(evt_nlo_t), intent(inout) :: evt end subroutine evt_nlo_compute_real <>= module subroutine evt_nlo_compute_real (evt) class(evt_nlo_t), intent(inout) :: evt integer :: i_phs, i_term if (debug_on) 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) associate (event_deps => evt%event_deps) call evt%process_instance%compute_sqme_rad (i_term, i_phs, & is_subtraction = .false.) evt%sqme_rad = evt%process_instance%get_sqme (i_term) end associate end subroutine evt_nlo_compute_real @ %def evt_nlo_compute_real @ This routine calls the evaluation of the singular regions only for all emission matrix elements. This is needed for the combined mode. It returns the sum of all valid real matrix elements. <>= procedure :: compute_all_sqme_rad => evt_nlo_compute_all_sqme_rad <>= module function evt_nlo_compute_all_sqme_rad (evt) result (sqme) class(evt_nlo_t), intent(inout) :: evt real(default) :: sqme end function evt_nlo_compute_all_sqme_rad <>= module function evt_nlo_compute_all_sqme_rad (evt) result (sqme) class(evt_nlo_t), intent(inout) :: evt real(default) :: sqme integer :: i_phs, i_term if (debug_on) call msg_debug (D_TRANSFORMS, "evt_nlo_compute_all_sqme_rad") sqme = zero do i_term = 1, size (evt%process_instance%term) if (evt%is_valid_event (i_term)) then associate (term => evt%process_instance%term(i_term)) if (term%nlo_type == NLO_REAL .and. & .not. term%is_subtraction ()) then i_phs = evt%process_instance%kin(i_term)%i_phs call evt%process_instance%compute_sqme_rad ( & i_term, i_phs, is_subtraction = .false.) sqme = sqme + evt%process_instance%get_sqme (i_term) end if end associate end if end do end function evt_nlo_compute_all_sqme_rad @ %def evt_nlo_compute_all_sqme_rad @ Boosts the given four vector [[p_lab]] to the Born or real CMS depending on the number of given momenta. Unfortunately, all boosts available via [[get_boost_to_cms]] are Born-like, so we need to compute the boost to the real CMS here manually. We cannot rely on [[i_term]] in order to determine whether to apply a Born-like or a real boost as we also need a real boost to compute the weights of the Born-like subevents as implemented in [[evt_nlo_generate_weighted]]. <>= procedure :: boost_to_cms => evt_nlo_boost_to_cms <>= module 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 end function evt_nlo_boost_to_cms <>= module 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(vector4_t) :: p0, p1 type(lorentz_transformation_t) :: lt_lab_to_cms, lt real(default) :: sqrts_hat integer :: i_boost, n_legs_born if (evt%event_deps%lab_is_cm) then lt_lab_to_cms = identity else n_legs_born = size (evt%event_deps%p_born_lab%phs_point(1)) if (size (p_lab) == n_legs_born) then i_boost = evt%get_i_term () lt_lab_to_cms = evt%process_instance%get_boost_to_cms (i_boost) else sqrts_hat = (p_lab%select (1) + p_lab%select (2))**1 p0 = p_lab%select (1) + p_lab%select (2) lt = boost (p0, sqrts_hat) p1 = inverse(lt) * p_lab%select (1) lt_lab_to_cms = inverse (lt * rotation_to_2nd (3, space_part (p1))) end if end if p_cms = lt_lab_to_cms * p_lab end function evt_nlo_boost_to_cms @ %def evt_nlo_boost_to_cms @ Boosts the given four vector [[p_cms]] from the Born CMS to the lab system. It should not be called for ISR as in this case, the Born CMS and the real CMS differ. <>= procedure :: boost_to_lab => evt_nlo_boost_to_lab <>= module 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 end function evt_nlo_boost_to_lab <>= module 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 (evt%event_deps%lab_is_cm) then lt_cms_to_lab = identity else i_boost = evt%get_i_term () 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 @ <>= procedure :: setup_general_event_kinematics => & evt_nlo_setup_general_event_kinematics <>= module 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 end subroutine evt_nlo_setup_general_event_kinematics <>= module 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%lab_is_cm = process_instance%lab_is_cm (1) select type (pcm => process_instance%pcm) type is (pcm_nlo_t) n_born = pcm%region_data%n_legs_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 @ <>= procedure :: setup_real_event_kinematics => & evt_nlo_setup_real_event_kinematics <>= module 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 end subroutine evt_nlo_setup_real_event_kinematics <>= module 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_nlo_t) n_real = pcm%region_data%n_legs_real end select i_real = evt%process%get_first_real_term () select type (phs => process_instance%kin(i_real)%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_nlo_t) if (allocated (pcm%region_data%alr_contributors)) then allocate (event_deps%contributors & (size (pcm%region_data%alr_contributors))) event_deps%contributors = pcm%region_data%alr_contributors end if if (allocated (pcm%region_data%alr_to_i_contributor)) then allocate (event_deps%alr_to_i_con & (size (pcm%region_data%alr_to_i_contributor))) event_deps%alr_to_i_con = pcm%region_data%alr_to_i_contributor end if end select end associate end subroutine evt_nlo_setup_real_event_kinematics @ %def evt_nlo_setup_real_event_kinematics @ <>= procedure :: set_mode => evt_nlo_set_mode <>= module subroutine evt_nlo_set_mode (evt, process_instance) class(evt_nlo_t), intent(inout) :: evt type(process_instance_t), intent(in) :: process_instance end subroutine evt_nlo_set_mode <>= module 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_nlo_t) if (pcm%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 subroutine evt_nlo_set_mode @ %def evt_nlo_set_mode @ <>= procedure :: is_valid_event => evt_nlo_is_valid_event <>= module 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 end function evt_nlo_is_valid_event <>= module 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 @ Retrieves the actual quantum numbers chosen in [[evt_nlo_prepare_new_event]]. <>= procedure :: get_selected_quantum_numbers => & evt_nlo_get_selected_quantum_numbers <>= module function evt_nlo_get_selected_quantum_numbers & (evt, i_flv) result (qn_select) class(evt_nlo_t), intent(in) :: evt integer, intent(in) :: i_flv type(quantum_numbers_t), dimension(:), allocatable :: qn_select end function evt_nlo_get_selected_quantum_numbers <>= module function evt_nlo_get_selected_quantum_numbers & (evt, i_flv) result (qn_select) class(evt_nlo_t), intent(in) :: evt integer, intent(in) :: i_flv type(quantum_numbers_t), dimension(:), allocatable :: qn_select integer :: i_term, index i_term = evt%get_i_term () associate (term => evt%process_instance%term(i_term)) index = term%connected%matrix%get_qn_index (i_flv, i_sub = 0) qn_select = term%connected%matrix%get_quantum_numbers (index) end associate end function evt_nlo_get_selected_quantum_numbers @ %def evt_nlo_get_selected_quantum_numbers @ Selects a flavor structure for Born subevents, such that each possible flavor structure is as probable as its portion of the sum of Born matrix elements over all flavors. For non-Born Born-like subevents, no Born matrix elements are available. We always choose [[i_flv = 1]] in this case. If all terms are active, i.e. in a full NLO calculation, the flavors of Born-like subevents will be distributed according to the Born matrix elements only, to avoid issues with matrix elements of different sign and assure a LO flavor distribution. Likewise, the real-like event flavors are distributed according to the real matrix elements. Here, we need to make sure to not mix matrix elements from different real terms and instead determine the flavor for each subevent based on just the matrix elements for one of the terms. The implementation below assumes that in the sequence of NLO terms, the Born term is immediately followed by all the real terms which are again followed by the subtraction, the virtual and the DGLAP term. Both flavor structures can be determined without correlation as the flavors will only become important for events to be matched to a parton shower and in this case we will only generate either a single Born-like or a single real-like event which are not part of an event group. In case all subevents failed the cuts, all [[sqme]]s were set to $0$ so we cannot determine the flavor in this way. In this case, we always choose the first flavor structure given by the matrix-element generator with [[i_flv = 1]]. Ideally, having to choose a particle set here would not be necessary as it is also chosen in [[particle_set_init_interaction]] which in the current approach is disabled by supplying [[qn_select]] explicitly based on the flavors chosen here. <>= procedure :: prepare_new_event => evt_nlo_prepare_new_event <>= module 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 end subroutine evt_nlo_prepare_new_event <>= module 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, i_flv, i_core, emitter, n_in logical, save :: warn_once = .true. class(prc_core_t), pointer :: core => null () call evt%reset () call evt%rng%generate (x) do i = 1, size (evt%process_instance%term) associate (term => evt%process_instance%term(i)) if (evt%i_evaluation == 0) then if (term%nlo_type == BORN) then allocate (sqme_flv (term%config%data%n_flv)) exit end if else if (term%nlo_type == NLO_REAL .and. .not. term%is_subtraction()) then allocate (sqme_flv (term%config%data%n_flv)) exit end if end if end associate end do sqme_total = zero sqme_flv = zero i_core = evt%process%get_i_core (i_term) core => evt%process%get_core_ptr (i_core) do i = 1, size (evt%process_instance%term) associate (term => evt%process_instance%term(i)) if (i == evt%i_evaluation + 1 .and. (term%nlo_type == BORN .or. & (term%nlo_type == NLO_REAL .and. .not. term%is_subtraction())) ) then sqme_total = sqme_total + real (sum ( term%connected%matrix%get_matrix_element ())) !!! TODO (VR 2020-02-19) figure out why this select type is needed for prc_omega_t !!! For NLO and prc_omega_t the connected trace seems to be set up incorrectly! !!! (PS 2020-11-05) This leads to real events of processes with structure functions !!! having a wrong flavor distribution if computed with O'Mega. !!! The flavor distributions are identical with and also without the special case !!! for O'Mega and wrong in both cases. !!! However, this case it is not critical as long as O'Mega does not provide matrix elements !!! exclusive in coupling orders and is thus only rarely used for NLO applications anyways select type (core) class is (prc_external_t) do i_flv = 1, size (sqme_flv) if (allocated (term%passed_array)) then if (term%passed .and. .not. term%passed_array(i_flv)) cycle end if sqme_flv(i_flv) = sqme_flv(i_flv) & + real (term%connected%matrix%get_matrix_element ( & term%connected%matrix%get_qn_index (i_flv, i_sub = 0))) end do class default sqme_flv = sqme_flv & + real (term%connected%matrix%get_matrix_element ()) emitter = evt%process_instance%kin(i)%emitter n_in = evt%process_instance%kin(i)%n_in if (warn_once .and. term%nlo_type == NLO_REAL .and. emitter <= n_in) then warn_once = .false. call msg_warning("evt_nlo_prepare_new_event: fNLO flavor& & distributions with O'Mega are wrong.") end if end select end if end associate end do if (debug2_active (D_TRANSFORMS)) then if (.not. nearly_equal(sqme_total, sum (sqme_flv))) then call msg_warning ("evt_nlo_prepare_new_event: & &sum over flavored sqmes does not match total sqme.") end if end if !!! Need absolute values to take into account negative weights x = x * abs (sqme_total) s = abs (sqme_flv (1)) evt%selected_i_flv = 1 if (s < x) then do i_flv = 2, size (sqme_flv) s = s + abs (sqme_flv (i_flv)) if (s > x) then evt%selected_i_flv = i_flv exit end if end do end if 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]]>>= <> module events <> <> 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 process_stacks use event_base use event_transforms <> <> <> <> interface <> end interface contains <> end module events @ %def events @ <<[[events_sub.f90]]>>= <> submodule (events) events_s <> 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 pcm, only: pcm_nlo_workspace_t use decays use evt_nlo use phs_fks, only: SQRTS_FIXED, SQRTS_VAR implicit none contains <> end submodule events_s @ %def events_s @ \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. <>= 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 <> end type event_config_t @ %def event_config_t @ Output. <>= procedure :: write => event_config_write <>= module 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 end subroutine event_config_write <>= module 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]]. <>= public :: event_t <>= 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 <> end type event_t @ %def event_t @ <>= procedure :: clone => event_clone <>= module subroutine event_clone (event, event_new) class(event_t), intent(in), target :: event class(event_t), intent(out), target:: event_new end subroutine event_clone <>= module 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. <>= procedure :: final => event_final <>= module subroutine event_final (object) class(event_t), intent(inout) :: object end subroutine event_final <>= module 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. <>= procedure :: write => event_write <>= module 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 end subroutine event_write <>= module 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. Gfortran 7/8/9 bug, has to remain in the main module: <>= procedure :: basic_init => event_init <>= 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. <>= procedure :: set_sigma => event_set_sigma procedure :: set_n => event_set_n <>= elemental module subroutine event_set_sigma (event, sigma) class(event_t), intent(inout) :: event real(default), intent(in) :: sigma end subroutine event_set_sigma elemental module subroutine event_set_n (event, n) class(event_t), intent(inout) :: event integer, intent(in) :: n end subroutine event_set_n <>= elemental module 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 module 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. <>= procedure :: import_transform => event_import_transform <>= module subroutine event_import_transform (event, evt) class(event_t), intent(inout) :: event class(evt_t), intent(inout), pointer :: evt end subroutine event_import_transform <>= module 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. <>= procedure :: connect => event_connect <>= module 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 end subroutine event_connect <>= module 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. <>= procedure :: set_selection => event_set_selection procedure :: set_reweight => event_set_reweight procedure :: set_analysis => event_set_analysis <>= module subroutine event_set_selection (event, ef_selection) class(event_t), intent(inout) :: event class(expr_factory_t), intent(in) :: ef_selection end subroutine event_set_selection module subroutine event_set_reweight (event, ef_reweight) class(event_t), intent(inout) :: event class(expr_factory_t), intent(in) :: ef_reweight end subroutine event_set_reweight module subroutine event_set_analysis (event, ef_analysis) class(event_t), intent(inout) :: event class(expr_factory_t), intent(in) :: ef_analysis end subroutine event_set_analysis <>= module 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 module 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 module 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. <>= procedure :: setup_expressions => event_setup_expressions <>= module subroutine event_setup_expressions (event) class(event_t), intent(inout), target :: event end subroutine event_setup_expressions <>= module 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. <>= procedure :: evaluate_transforms => event_evaluate_transforms <>= module subroutine event_evaluate_transforms (event, r) class(event_t), intent(inout) :: event real(default), dimension(:), intent(in), optional :: r end subroutine event_evaluate_transforms <>= module 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) :: weight_over_sqme integer :: i_term, emitter, n_in logical :: failed_but_keep failed_but_keep = .false. if (debug_on) 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 if (debug_on) call msg_debug & (D_TRANSFORMS, "Before event transformations") if (debug_on) call msg_debug & (D_TRANSFORMS, "event%weight_prc", event%weight_prc) if (debug_on) call msg_debug & (D_TRANSFORMS, "event%sqme_prc", event%sqme_prc) evt => event%transform_first do while (associated (evt)) call print_transform_name_if_debug () if (evt%only_weighted_events) then select type (evt) type is (evt_nlo_t) i_term = evt%get_i_term () failed_but_keep = .not. evt%is_valid_event (i_term) & .and. evt%keep_failed_events if (.not. any(evt%process_instance%term%passed .and. evt%process_instance%term%active) & .and. .not. evt%keep_failed_events) return end select if (abs (event%weight_prc) > 0._default) then weight_over_sqme = event%weight_prc / event%sqme_prc call evt%generate_weighted (event%sqme_prc) event%weight_prc = weight_over_sqme * event%sqme_prc select type (evt) type is (evt_nlo_t) if (.not. evt%is_valid_event (i_term)) event%weight_prc = 0 end select else if (.not. failed_but_keep) exit end if else call evt%generate_unweighted () end if if (signal_is_pending ()) return select type (evt) type is (evt_nlo_t) if (evt%i_evaluation > 0) then emitter = evt%process_instance%kin(i_term)%emitter n_in = evt%process_instance%kin(i_term)%n_in select type (pcm_work => evt%process_instance%term(i_term)%pcm_work) type is (pcm_nlo_workspace_t) if (emitter <= n_in .and. pcm_work%isr_kinematics%isr_mode == SQRTS_VAR) then call evt%connected_set_real_IS_momenta () end if end select end if end select 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) evt%particle_set_nlo (event%i_event + 1) = evt%particle_set evt%i_evaluation = evt%i_evaluation + 1 call event%link_particle_set & (evt%particle_set_nlo(event%i_event + 1)) end select else call event%link_particle_set (evt%particle_set) end if end if if (debug_on) call msg_debug & (D_TRANSFORMS, "After event transformations") if (debug_on) call msg_debug & (D_TRANSFORMS, "event%weight_prc", event%weight_prc) if (debug_on) call msg_debug & (D_TRANSFORMS, "event%sqme_prc", event%sqme_prc) if (debug_on) 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. <>= procedure :: set_index => event_set_index procedure :: increment_index => event_increment_index <>= module subroutine event_set_index (event, index) class(event_t), intent(inout) :: event integer, intent(in) :: index end subroutine event_set_index module subroutine event_increment_index (event, offset) class(event_t), intent(inout) :: event integer, intent(in), optional :: offset end subroutine event_increment_index <>= module 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 module 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. <>= procedure :: evaluate_expressions => event_evaluate_expressions <>= module subroutine event_evaluate_expressions (event) class(event_t), intent(inout) :: event end subroutine event_evaluate_expressions <>= module subroutine event_evaluate_expressions (event) class(event_t), intent(inout) :: event if (event%has_valid_particle_set ()) then call event%expr%fill_subevt (event%get_particle_set_ptr ()) 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. <>= procedure :: passed_selection => event_passed_selection <>= module function event_passed_selection (event) result (flag) class(event_t), intent(in) :: event logical :: flag end function event_passed_selection <>= module 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. <>= procedure :: store_alt_values => event_store_alt_values <>= module subroutine event_store_alt_values (event) class(event_t), intent(inout) :: event end subroutine event_store_alt_values <>= module 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 @ <>= procedure :: is_nlo => event_is_nlo <>= module function event_is_nlo (event) result (is_nlo) logical :: is_nlo class(event_t), intent(in) :: event end function event_is_nlo <>= module 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_work => event%instance%pcm_work) type is (pcm_nlo_workspace_t) is_nlo = pcm_work%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. <>= procedure :: reset_contents => event_reset_contents procedure :: reset_index => event_reset_index <>= module subroutine event_reset_contents (event) class(event_t), intent(inout) :: event end subroutine event_reset_contents module subroutine event_reset_index (event) class(event_t), intent(inout) :: event end subroutine event_reset_index <>= module 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 module 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. <>= procedure :: import_instance_results => event_import_instance_results <>= module subroutine event_import_instance_results (event) class(event_t), intent(inout) :: event end subroutine event_import_instance_results <>= module 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 (), & n_dropped = event%instance%get_n_dropped () & ) 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. <>= 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 <>= module subroutine event_accept_sqme_ref (event) class(event_t), intent(inout) :: event end subroutine event_accept_sqme_ref module subroutine event_accept_sqme_prc (event) class(event_t), intent(inout) :: event end subroutine event_accept_sqme_prc module subroutine event_accept_weight_ref (event) class(event_t), intent(inout) :: event end subroutine event_accept_weight_ref module subroutine event_accept_weight_prc (event) class(event_t), intent(inout) :: event end subroutine event_accept_weight_prc <>= module 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 module 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 module 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 module 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. <>= procedure :: update_normalization => event_update_normalization <>= module subroutine event_update_normalization (event, mode_ref) class(event_t), intent(inout) :: event integer, intent(in), optional :: mode_ref end subroutine event_update_normalization <>= module 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. <>= procedure :: check => event_check <>= module subroutine event_check (event) class(event_t), intent(inout) :: event end subroutine event_check <>= module 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. <>= procedure :: generate => event_generate <>= module 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 end subroutine event_generate <>= module 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. <>= procedure :: get_hard_particle_set => event_get_hard_particle_set <>= module subroutine event_get_hard_particle_set (event, pset) class(event_t), intent(in) :: event type(particle_set_t), intent(out) :: pset end subroutine event_get_hard_particle_set <>= module 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. <>= procedure :: select => event_select <>= module subroutine event_select (event, i_mci, i_term, channel) class(event_t), intent(inout) :: event integer, intent(in) :: i_mci, i_term, channel end subroutine event_select <>= module 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. <>= procedure :: set_hard_particle_set => event_set_hard_particle_set <>= module subroutine event_set_hard_particle_set (event, particle_set) class(event_t), intent(inout) :: event type(particle_set_t), intent(in) :: particle_set end subroutine event_set_hard_particle_set <>= module 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. <>= procedure :: set_alpha_qcd_forced => event_set_alpha_qcd_forced <>= module subroutine event_set_alpha_qcd_forced (event, alpha_qcd) class(event_t), intent(inout) :: event real(default), intent(in) :: alpha_qcd end subroutine event_set_alpha_qcd_forced <>= module 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. <>= procedure :: set_scale_forced => event_set_scale_forced <>= module subroutine event_set_scale_forced (event, scale) class(event_t), intent(inout) :: event real(default), intent(in) :: scale end subroutine event_set_scale_forced <>= module 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 a [[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. <>= procedure :: recalculate => event_recalculate <>= module subroutine event_recalculate (event, update_sqme, weight_factor, & recover_beams, recover_phs, check_match, success) 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 logical, intent(in), optional :: check_match logical, intent(out), optional :: success end subroutine event_recalculate <>= module subroutine event_recalculate (event, update_sqme, weight_factor, & recover_beams, recover_phs, check_match, success) 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 logical, intent(in), optional :: check_match logical, intent(out), optional :: success 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 (present (success)) success = .false. 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, check_match, success) if (present (success)) then if (.not. success) return end if 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). <>= 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 <>= module function event_get_process_ptr (event) result (ptr) class(event_t), intent(in) :: event type(process_t), pointer :: ptr end function event_get_process_ptr module function event_get_process_instance_ptr (event) result (ptr) class(event_t), intent(in) :: event type(process_instance_t), pointer :: ptr end function event_get_process_instance_ptr module function event_get_model_ptr (event) result (model) class(event_t), intent(in) :: event class(model_data_t), pointer :: model end function event_get_model_ptr <>= module 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 module 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 module 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. <>= procedure :: get_i_mci => event_get_i_mci procedure :: get_i_term => event_get_i_term procedure :: get_channel => event_get_channel <>= module function event_get_i_mci (event) result (i_mci) class(event_t), intent(in) :: event integer :: i_mci end function event_get_i_mci module function event_get_i_term (event) result (i_term) class(event_t), intent(in) :: event integer :: i_term end function event_get_i_term module function event_get_channel (event) result (channel) class(event_t), intent(in) :: event integer :: channel end function event_get_channel <>= module 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 module 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 module 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. <>= procedure :: has_transform => event_has_transform <>= module function event_has_transform (event) result (flag) class(event_t), intent(in) :: event logical :: flag end function event_has_transform <>= module 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. <>= procedure :: get_norm_mode => event_get_norm_mode <>= elemental module function event_get_norm_mode (event) result (norm_mode) class(event_t), intent(in) :: event integer :: norm_mode end function event_get_norm_mode <>= elemental module 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. <>= procedure :: get_kinematical_weight => event_get_kinematical_weight <>= module function event_get_kinematical_weight (event) result (f) class(event_t), intent(in) :: event real(default) :: f end function event_get_kinematical_weight <>= module 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. <>= 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 <>= module function event_has_index (event) result (flag) class(event_t), intent(in) :: event logical :: flag end function event_has_index module function event_get_index (event) result (index) class(event_t), intent(in) :: event integer :: index end function event_get_index module function event_get_fac_scale (event) result (fac_scale) class(event_t), intent(in) :: event real(default) :: fac_scale end function event_get_fac_scale module function event_get_alpha_s (event) result (alpha_s) class(event_t), intent(in) :: event real(default) :: alpha_s end function event_get_alpha_s module function event_get_sqrts (event) result (sqrts) class(event_t), intent(in) :: event real(default) :: sqrts end function event_get_sqrts module function event_get_polarization (event) result (pol) class(event_t), intent(in) :: event real(default), dimension(:), allocatable :: pol end function event_get_polarization module function event_get_beam_file (event) result (file) class(event_t), intent(in) :: event type(string_t) :: file end function event_get_beam_file module function event_get_process_name (event) result (name) class(event_t), intent(in) :: event type(string_t) :: name end function event_get_process_name <>= module 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 module 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 module 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 module 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 module 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 module function event_get_polarization (event) result (pol) class(event_t), intent(in) :: event real(default), dimension(:), allocatable :: pol pol = event%instance%get_polarization () end function event_get_polarization module 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 module 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. <>= procedure :: get_actual_calls_total => event_get_actual_calls_total <>= elemental module function event_get_actual_calls_total (event) result (n) class(event_t), intent(in) :: event integer :: n end function event_get_actual_calls_total <>= elemental module 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). <>= public :: pacify <>= interface pacify module procedure pacify_event end interface pacify <>= module subroutine pacify_event (event) class(event_t), intent(inout) :: event class(evt_t), pointer :: evt end subroutine pacify_event <>= module 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]]>>= <> module events_ut use unit_tests use events_uti <> <> contains <> end module events_ut @ %def events_ut @ <<[[events_uti.f90]]>>= <> module events_uti <> <> 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 <> <> contains <> end module events_uti @ %def events_uti @ API: driver for the unit tests below. <>= public :: events_test <>= subroutine events_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> end subroutine events_test @ %def events_test @ \subsubsection{Empty event record} <>= call test (events_1, "events_1", & "empty event record", & u, results) <>= public :: events_1 <>= 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} <>= call test (events_2, "events_2", & "generate event", & u, results) <>= public :: events_2 <>= 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. <>= call test (events_4, "events_4", & "recover event", & u, results) <>= public :: events_4 <>= 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(process_t), allocatable, target :: process2 type(process_instance_t), allocatable, target :: process2_instance type(particle_set_t) :: particle_set 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 = event%get_particle_set_ptr () ! NB: 'particle_set' contains pointers to the model within 'process' call event%final () deallocate (event) write (u, "(A)") write (u, "(A)") "* Recover event from particle set" write (u, "(A)") allocate (process2) allocate (process2_instance) call prepare_test_process (process2, process2_instance, model) call process2_instance%setup_event_data () allocate (event) call event%basic_init () call event%connect (process2_instance, process2%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 (process2, process2_instance) deallocate (process2_instance) deallocate (process2) 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. <>= call test (events_5, "events_5", & "partially recover event", & u, results) <>= public :: events_5 <>= 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(process_t), allocatable, target :: process2 type(process_instance_t), allocatable, target :: process2_instance type(particle_set_t) :: particle_set 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 = event%get_particle_set_ptr () sqme = event%get_sqme_ref () weight = event%get_weight_ref () call event%final () deallocate (event) write (u, "(A)") write (u, "(A)") "* Recover event from particle set" write (u, "(A)") allocate (process2) allocate (process2_instance) call prepare_test_process (process2, process2_instance, model) call process2_instance%setup_event_data () allocate (event) call event%basic_init () call event%connect (process2_instance, process2%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 (process2, process2_instance) deallocate (process2_instance) deallocate (process2) 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. <>= call test (events_6, "events_6", & "decays", & u, results) <>= public :: events_6 <>= 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 () 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. <>= call test (events_7, "events_7", & "decay options", & u, results) <>= public :: events_7 <>= 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 () 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]]>>= <> module eio_raw <> <> use event_base use event_handles, only: event_handle_t use eio_data use eio_base use events <> <> <> <> interface <> end interface end module eio_raw @ %def eio_raw @ <<[[eio_raw_sub.f90]]>>= <> submodule (eio_raw) eio_raw_s use io_units use diagnostics use model_data use particles implicit none contains <> end submodule eio_raw_s @ %def eio_raw_s @ \subsection{File Format Version} This is the current default file version. <>= 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. <>= public :: eio_raw_t <>= 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. logical :: use_alphas_from_file = .false. logical :: use_scale_from_file = .false. logical :: fixed_order_nlo = .false. integer :: file_version = CURRENT_FILE_VERSION contains <> 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. <>= procedure :: write => eio_raw_write <>= module subroutine eio_raw_write (object, unit) class(eio_raw_t), intent(in) :: object integer, intent(in), optional :: unit end subroutine eio_raw_write <>= module 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 write (u, "(3x,A,L1)") "Alpha_s from file = ", & object%use_alphas_from_file write (u, "(3x,A,L1)") "Scale from file = ", & object%use_scale_from_file write (u, "(3x,A,L1)") "Events for fNLO = ", & object%fixed_order_nlo 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. <>= procedure :: final => eio_raw_final <>= module subroutine eio_raw_final (object) class(eio_raw_t), intent(inout) :: object end subroutine eio_raw_final <>= module 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. <>= procedure :: set_parameters => eio_raw_set_parameters <>= module subroutine eio_raw_set_parameters (eio, check, & use_alphas_from_file, use_scale_from_file, fixed_order_nlo, & version_string, extension) class(eio_raw_t), intent(inout) :: eio logical, intent(in), optional :: check, use_alphas_from_file, & use_scale_from_file, fixed_order_nlo type(string_t), intent(in), optional :: version_string type(string_t), intent(in), optional :: extension end subroutine eio_raw_set_parameters <>= module subroutine eio_raw_set_parameters (eio, check, use_alphas_from_file, & use_scale_from_file, fixed_order_nlo, version_string, extension) class(eio_raw_t), intent(inout) :: eio logical, intent(in), optional :: check, use_alphas_from_file, & use_scale_from_file, fixed_order_nlo type(string_t), intent(in), optional :: version_string type(string_t), intent(in), optional :: extension if (present (check)) eio%check = check if (present (use_alphas_from_file)) eio%use_alphas_from_file = & use_alphas_from_file if (present (use_scale_from_file)) eio%use_scale_from_file = & use_scale_from_file if (present (fixed_order_nlo)) eio%fixed_order_nlo = & fixed_order_nlo 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. <>= procedure :: init_out => eio_raw_init_out <>= module 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 end subroutine eio_raw_init_out <>= module 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. <>= procedure :: init_in => eio_raw_init_in <>= module 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 end subroutine eio_raw_init_in <>= module 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. <>= procedure :: switch_inout => eio_raw_switch_inout <>= module subroutine eio_raw_switch_inout (eio, success) class(eio_raw_t), intent(inout) :: eio logical, intent(out), optional :: success end subroutine eio_raw_switch_inout <>= module 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. <>= procedure :: output => eio_raw_output <>= module subroutine eio_raw_output & (eio, event, i_prc, reading, passed, pacify, event_handle) class(eio_raw_t), intent(inout) :: eio class(generic_event_t), intent(in), target :: event logical, intent(in), optional :: reading, passed, pacify class(event_handle_t), intent(inout), optional :: event_handle integer, intent(in) :: i_prc end subroutine eio_raw_output <>= module subroutine eio_raw_output & (eio, event, i_prc, reading, passed, pacify, event_handle) class(eio_raw_t), intent(inout) :: eio class(generic_event_t), intent(in), target :: event logical, intent(in), optional :: reading, passed, pacify class(event_handle_t), intent(inout), optional :: event_handle 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%get_n_dropped () 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]]. <>= procedure :: input_i_prc => eio_raw_input_i_prc procedure :: input_event => eio_raw_input_event <>= module 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 end subroutine eio_raw_input_i_prc module subroutine eio_raw_input_event (eio, event, iostat, event_handle) class(eio_raw_t), intent(inout) :: eio class(generic_event_t), intent(inout), target :: event integer, intent(out) :: iostat class(event_handle_t), intent(inout), optional :: event_handle end subroutine eio_raw_input_event <>= module 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 module subroutine eio_raw_input_event (eio, event, iostat, event_handle) class(eio_raw_t), intent(inout) :: eio class(generic_event_t), intent(inout), target :: event integer, intent(out) :: iostat class(event_handle_t), intent(inout), optional :: event_handle integer :: event_index, i_mci, i_term, channel, i real(default) :: weight, excess, sqme integer :: n_dropped 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) n_dropped 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, & n_dropped = n_dropped) 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) if (eio%use_alphas_from_file .or. eio%use_scale_from_file) then call event%recalculate (update_sqme = .true.) if (eio%fixed_order_nlo) then if (event%weight_prc /= event%weight_ref .and. & event%weight_prc == 0) then event%weight_prc = event%weight_ref end if end if end if 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 @ <>= procedure :: skip => eio_raw_skip <>= module subroutine eio_raw_skip (eio, iostat) class(eio_raw_t), intent(inout) :: eio integer, intent(out) :: iostat end subroutine eio_raw_skip <>= module 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]]>>= <> module eio_raw_ut use unit_tests use eio_raw_uti <> <> contains <> end module eio_raw_ut @ %def eio_raw_ut @ <<[[eio_raw_uti.f90]]>>= <> module eio_raw_uti <> <> 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 <> <> contains <> end module eio_raw_uti @ %def eio_raw_uti @ API: driver for the unit tests below. <>= public :: eio_raw_test <>= subroutine eio_raw_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> end subroutine eio_raw_test @ %def eio_raw_test @ \subsubsection{Test I/O methods} We test the implementation of all I/O methods. <>= call test (eio_raw_1, "eio_raw_1", & "read and write event contents", & u, results) <>= public :: eio_raw_1 <>= 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, & run_id = var_str ("run_test")) 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. <>= call test (eio_raw_2, "eio_raw_2", & "handle multiple weights", & u, results) <>= public :: eio_raw_2 <>= 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, & run_id = var_str ("run_test")) call process_instance%setup_event_data () call data%init (n_proc = 1, n_alt = 2) call var_list%append_log (var_str ("?unweighted"), .false., & intrinsic = .true.) call var_list%append_string (var_str ("$sample_normalization"), & var_str ("auto"), intrinsic = .true.) call var_list%append_real (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. Due to the gfortran 7/8/9 bug that leads to segmentation violation if polymorphic user-defined derived types are allocated in routines within submodules, this module remains without submodule until we can switch to gfortran v10 or newer. <<[[dispatch_transforms.f90]]>>= <> module dispatch_transforms <> <> use process use variables use system_defs, only: LF use system_dependencies, only: LHAPDF6_AVAILABLE use sf_lhapdf, only: lhapdf_initialize use pdf, only: pdf_data_t 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 hepmc_interface, only: HEPMC3_MODE_HEPMC2, HEPMC3_MODE_HEPMC3 use hepmc_interface, only: HEPMC3_MODE_ROOT, HEPMC3_MODE_ROOTTREE use hepmc_interface, only: HEPMC3_MODE_HEPEVT 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 shower_pythia8 use hadrons use mlm_matching use powheg_matching use ckkw_matching use tauola_interface !NODEP! use evt_nlo <> <> contains <> end module dispatch_transforms @ %def dispatch_transforms @ <>= public :: dispatch_evt_nlo <>= 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 @ <>= public :: dispatch_evt_resonance <>= 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. <>= public :: dispatch_evt_isr_epa_handler <>= 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 logical :: isr_keep_mass 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")) isr_keep_mass = & var_list%get_lval (var_str ("?isr_handler_keep_mass")) 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, isr_keep_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 @ <>= public :: dispatch_evt_decay <>= 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 @ <>= public :: dispatch_evt_shower <>= 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 (PS_PYTHIA8) allocate (shower_pythia8_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, os_data) call dispatch_matching (evt, settings, var_list, process_name, evt%pdf_data) class default call dispatch_matching (evt, settings, var_list, process_name) end select end subroutine dispatch_evt_shower @ %def dispatch_evt_shower @ <>= public :: dispatch_evt_shower_hook <>= subroutine dispatch_evt_shower_hook (hook, var_list, process_instance, beam_structure, pdf_set) 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 type(beam_structure_t), intent(in) :: beam_structure integer, intent(in) :: pdf_set type(pdf_data_t) :: pdf_data type(string_t) :: lhapdf_file, lhapdf_dir integer :: lhapdf_member if (var_list%get_lval (var_str ('?powheg_matching'))) then call msg_message ("Integration hook: add POWHEG hook") allocate (powheg_matching_hook_t :: hook) select type (hook) type is (powheg_matching_hook_t) 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, pdf_data%pdf) end if call pdf_data%setup ("Shower", beam_structure, lhapdf_member, pdf_set) call hook%init (var_list, process_instance, pdf_data) end select else hook => null () end if end subroutine dispatch_evt_shower_hook @ %def dispatch_evt_shower_hook @ <>= public :: dispatch_matching <>= subroutine dispatch_matching (evt, settings, var_list, process_name, pdf_data) class(evt_t), intent(inout) :: evt type(shower_settings_t), intent(in) :: settings type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_name type(pdf_data_t), intent(in), optional :: pdf_data 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)) then call evt%matching%init (var_list, process_name) if (present(pdf_data)) then select type (matching => evt%matching) type is (powheg_matching_t) matching%process_deps%pdf_data = pdf_data end select end if end if end select end subroutine dispatch_matching @ %def dispatch_matching @ <>= public :: dispatch_evt_hadrons <>= 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. <>= public :: dispatch_eio <>= 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 logical :: check, keep_beams, keep_remnants, recover_beams logical :: use_alphas_from_file, use_scale_from_file logical :: fixed_order_nlo_events 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 integer :: lcio_run_id, hepmc3_mode logical :: show_process, show_transforms, show_decay, verbose, pacified logical :: dump_weights, dump_compressed, dump_summary, dump_screen logical :: proc_as_run_id, hepmc3_write_flows 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")) fixed_order_nlo_events = & var_list%get_lval (var_str ("?fixed_order_nlo_events")) 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, use_alphas_from_file, & use_scale_from_file, fixed_order_nlo_events, & 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 call eio%set_parameters (event_callback_nop_t (), 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")) hepmc3_write_flows = & var_list%get_lval (var_str ("?hepmc3_write_flows")) select case (char (var_list%get_sval (var_str ("$hepmc3_mode")))) case ("HepMC2") hepmc3_mode = HEPMC3_MODE_HEPMC2 case ("HepMC3") hepmc3_mode = HEPMC3_MODE_HEPMC3 case ("Root") hepmc3_mode = HEPMC3_MODE_ROOT if (extension_hepmc /= "root") then call msg_message ("Events: HepMC3 Root mode, using " // & "event sample extension 'root'") extension_hepmc = "root" end if case ("RootTree") hepmc3_mode = HEPMC3_MODE_ROOTTREE if (extension_hepmc /= "root") then call msg_message ("Events: HepMC3 RootTree mode, using " // & "event sample extension 'root'") extension_hepmc = "root" end if case ("HepEVT") hepmc3_mode = HEPMC3_MODE_HEPEVT case default call msg_fatal ("Only supported HepMC3 modes are: 'HepMC2', " // & "'HepMC3', 'HepEVT', 'Root', and 'RootTree'.") end select call eio%set_parameters (recover_beams, & use_alphas_from_file, use_scale_from_file, & extension = extension_hepmc, & output_cross_section = output_cross_section, & hepmc3_mode = hepmc3_mode, & hepmc3_write_flows = hepmc3_write_flows) 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")) proc_as_run_id = & var_list%get_lval (var_str ("?proc_as_run_id")) lcio_run_id = & var_list%get_ival (var_str ("lcio_run_id")) call eio%set_parameters (recover_beams, & use_alphas_from_file, use_scale_from_file, & extension_lcio, proc_as_run_id = proc_as_run_id, & lcio_run_id = lcio_run_id) 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]]>>= <> module dispatch_transforms_ut use unit_tests use dispatch_transforms_uti <> <> contains <> end module dispatch_transforms_ut @ %def dispatch_transforms_ut @ <<[[dispatch_transforms_uti.f90]]>>= <> module dispatch_transforms_uti <> <> 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 use event_transforms, only: evt_t use dispatch_transforms <> <> contains <> end module dispatch_transforms_uti @ %def dispatch_transforms_uti @ API: driver for the unit tests below. <>= public ::dispatch_transforms_test <>= subroutine dispatch_transforms_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> end subroutine dispatch_transforms_test @ %def dispatch_transforms_test @ \subsubsection{Event I/O} <>= call test (dispatch_transforms_1, "dispatch_transforms_1", & "event I/O", & u, results) <>= public :: dispatch_transforms_1 <>= 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 () 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. <>= call test (dispatch_transforms_2, "dispatch_transforms_2", & "event transforms", & u, results) <>= public :: dispatch_transforms_2 <>= 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 () 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/process_integration/process_integration.nw =================================================================== --- trunk/src/process_integration/process_integration.nw (revision 8839) +++ trunk/src/process_integration/process_integration.nw (revision 8840) @@ -1,23944 +1,23945 @@ % -*- 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]]>>= <> module subevt_expr <> <> use lorentz use subevents use variables use flavors use quantum_numbers use interactions use particles use expr_base <> <> <> <> interface <> end interface end module subevt_expr @ %def subevt_expr @ <<[[subevt_expr_sub.f90]]>>= <> submodule (subevt_expr) subevt_expr_s use constants, only: zero, one use io_units use format_utils, only: write_separator use diagnostics implicit none contains <> end submodule subevt_expr_s @ %def subevt_expr_s @ \subsection{Abstract base type} <>= 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 <> 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. <>= procedure :: base_write => subevt_expr_write <>= module subroutine subevt_expr_write (object, unit, pacified) class(subevt_expr_t), intent(in) :: object integer, intent(in), optional :: unit logical, intent(in), optional :: pacified end subroutine subevt_expr_write <>= module 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 object%var_list%write (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. <>= procedure (subevt_expr_final), deferred :: final procedure :: base_final => subevt_expr_final <>= module subroutine subevt_expr_final (object) class(subevt_expr_t), intent(inout) :: object end subroutine subevt_expr_final <>= module 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. <>= procedure (subevt_expr_setup_vars), deferred :: setup_vars procedure :: base_setup_vars => subevt_expr_setup_vars <>= module subroutine subevt_expr_setup_vars (expr, sqrts) class(subevt_expr_t), intent(inout), target :: expr real(default), intent(in) :: sqrts end subroutine subevt_expr_setup_vars <>= module 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 expr%var_list%append_real (var_str ("sqrts"), sqrts, & locked = .true., verbose = .false., intrinsic = .true.) call expr%var_list%append_real_ptr (var_str ("sqrts_hat"), & expr%sqrts_hat, is_known = expr%subevt_filled, & locked = .true., verbose = .false., intrinsic = .true.) call expr%var_list%append_int_ptr (var_str ("n_in"), expr%n_in, & is_known = expr%subevt_filled, & locked = .true., verbose = .false., intrinsic = .true.) call expr%var_list%append_int_ptr (var_str ("n_out"), expr%n_out, & is_known = expr%subevt_filled, & locked = .true., verbose = .false., intrinsic = .true.) call expr%var_list%append_int_ptr (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. <>= procedure :: setup_var_self => subevt_expr_setup_var_self <>= module subroutine subevt_expr_setup_var_self (expr) class(subevt_expr_t), intent(inout), target :: expr end subroutine subevt_expr_setup_var_self <>= module 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 expr%var_list%append_subevt_ptr & (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. <>= procedure :: link_var_list => subevt_expr_link_var_list <>= module 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 end subroutine subevt_expr_link_var_list <>= module 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 will not allocate the expression object. <>= procedure :: setup_selection => subevt_expr_setup_selection <>= module subroutine subevt_expr_setup_selection (expr, ef_cuts) class(subevt_expr_t), intent(inout), target :: expr class(expr_factory_t), intent(in) :: ef_cuts end subroutine subevt_expr_setup_selection <>= module 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. <>= procedure :: colorize => subevt_expr_colorize <>= module subroutine subevt_expr_colorize (expr, colorize_subevt) class(subevt_expr_t), intent(inout), target :: expr logical, intent(in) :: colorize_subevt end subroutine subevt_expr_colorize <>= module 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. <>= procedure :: reset_contents => subevt_expr_reset_contents procedure :: base_reset_contents => subevt_expr_reset_contents <>= module subroutine subevt_expr_reset_contents (expr) class(subevt_expr_t), intent(inout) :: expr end subroutine subevt_expr_reset_contents <>= module 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. <>= procedure :: base_evaluate => subevt_expr_evaluate <>= module subroutine subevt_expr_evaluate (expr, passed) class(subevt_expr_t), intent(inout) :: expr logical, intent(out) :: passed end subroutine subevt_expr_evaluate <>= module 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. <>= public :: parton_expr_t <>= 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 <> end type parton_expr_t @ %def parton_expr_t @ Finalizer. <>= procedure :: final => parton_expr_final <>= module subroutine parton_expr_final (object) class(parton_expr_t), intent(inout) :: object end subroutine parton_expr_final <>= module 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. <>= procedure :: write => parton_expr_write <>= module 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 end subroutine parton_expr_write <>= module 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. <>= procedure :: setup_vars => parton_expr_setup_vars <>= module subroutine parton_expr_setup_vars (expr, sqrts) class(parton_expr_t), intent(inout), target :: expr real(default), intent(in) :: sqrts end subroutine parton_expr_setup_vars <>= module 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. <>= 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 <>= module subroutine parton_expr_setup_scale (expr, ef_scale) class(parton_expr_t), intent(inout), target :: expr class(expr_factory_t), intent(in) :: ef_scale end subroutine parton_expr_setup_scale module 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 end subroutine parton_expr_setup_fac_scale module 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 end subroutine parton_expr_setup_ren_scale <>= module 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 module 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 module 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. <>= procedure :: setup_weight => parton_expr_setup_weight <>= module subroutine parton_expr_setup_weight (expr, ef_weight) class(parton_expr_t), intent(inout), target :: expr class(expr_factory_t), intent(in) :: ef_weight end subroutine parton_expr_setup_weight <>= module 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. <>= procedure :: setup_subevt => parton_expr_setup_subevt <>= module 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 end subroutine parton_expr_setup_subevt <>= module 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 expr%set_pdg_beam (f_beam%get_pdg ()) call expr%set_pdg_incoming (f_in%get_pdg ()) call expr%set_pdg_outgoing (f_out%get_pdg ()) call expr%set_p2_beam (f_beam%get_mass () ** 2) call expr%set_p2_incoming (f_in%get_mass () ** 2) call expr%set_p2_outgoing (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 <>= procedure :: renew_flv_content_subevt => parton_expr_renew_flv_content_subevt <>= module subroutine parton_expr_renew_flv_content_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 end subroutine parton_expr_renew_flv_content_subevt <>= module subroutine parton_expr_renew_flv_content_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 expr%i_beam = i_beam expr%i_in = i_in expr%i_out = i_out call expr%set_pdg_beam (f_beam%get_pdg ()) call expr%set_pdg_incoming (f_in%get_pdg ()) call expr%set_pdg_outgoing (f_out%get_pdg ()) 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_renew_flv_content_subevt @ %def parton_expr_renew_flv_content_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. <>= interface interaction_momenta_to_subevt module procedure interaction_momenta_to_subevt_id module procedure interaction_momenta_to_subevt_tr end interface <>= module 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 end subroutine interaction_momenta_to_subevt_id module 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 end subroutine interaction_momenta_to_subevt_tr <>= 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 (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 (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 (n_beam + n_in + i, & flv(j)%get_pdg (), vector4_null, & flv(j)%get_mass () ** 2) end do end subroutine interaction_to_subevt module 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 (- int%get_momenta (j_beam)) call subevt%set_p_incoming (- int%get_momenta (j_in)) call subevt%set_p_outgoing (int%get_momenta (j_out)) end subroutine interaction_momenta_to_subevt_id module 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 (- lt * int%get_momenta (j_beam)) call subevt%set_p_incoming (- lt * int%get_momenta (j_in)) call subevt%set_p_outgoing (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. <>= procedure :: fill_subevt => parton_expr_fill_subevt <>= module subroutine parton_expr_fill_subevt (expr, int) class(parton_expr_t), intent(inout) :: expr type(interaction_t), intent(in), target :: int end subroutine parton_expr_fill_subevt <>= module 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 = expr%get_sqrts_hat () 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. <>= procedure :: evaluate => parton_expr_evaluate <>= module 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), allocatable, intent(out) :: fac_scale real(default), allocatable, intent(out) :: ren_scale real(default), intent(out) :: weight real(default), intent(in), allocatable, optional :: scale_forced logical, intent(in), optional :: force_evaluation end subroutine parton_expr_evaluate <>= module 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), allocatable, intent(out) :: fac_scale real(default), allocatable, 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 (expr%has_fac_scale) then call expr%fac_scale%evaluate () if (expr%fac_scale%is_known ()) then if (.not. allocated (fac_scale)) then allocate (fac_scale, source = expr%fac_scale%get_real ()) else fac_scale = expr%fac_scale%get_real () end if else call msg_error ("Evaluate factorization scale expression: & &result undefined") end if end if if (expr%has_ren_scale) then call expr%ren_scale%evaluate () if (expr%ren_scale%is_known ()) then if (.not. allocated (ren_scale)) then allocate (ren_scale, source = expr%ren_scale%get_real ()) else ren_scale = expr%ren_scale%get_real () end if else call msg_error ("Evaluate renormalization scale expression: & &result undefined") end if 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. <>= procedure :: get_beam_index => parton_expr_get_beam_index procedure :: get_in_index => parton_expr_get_in_index <>= module subroutine parton_expr_get_beam_index (expr, i_beam) class(parton_expr_t), intent(in) :: expr integer, dimension(:), intent(out) :: i_beam end subroutine parton_expr_get_beam_index module subroutine parton_expr_get_in_index (expr, i_in) class(parton_expr_t), intent(in) :: expr integer, dimension(:), intent(out) :: i_in end subroutine parton_expr_get_in_index <>= module 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 module 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. <>= public :: event_expr_t <>= 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 <> end type event_expr_t @ %def event_expr_t @ Finalizer for the expressions. <>= procedure :: final => event_expr_final <>= module subroutine event_expr_final (object) class(event_expr_t), intent(inout) :: object end subroutine event_expr_final <>= module 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. <>= procedure :: write => event_expr_write <>= module 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 end subroutine event_expr_write <>= module 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. <>= procedure :: init => event_expr_init <>= module subroutine event_expr_init (expr, n_alt) class(event_expr_t), intent(out) :: expr integer, intent(in), optional :: n_alt end subroutine event_expr_init <>= module 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. <>= procedure :: setup_vars => event_expr_setup_vars <>= module subroutine event_expr_setup_vars (expr, sqrts) class(event_expr_t), intent(inout), target :: expr real(default), intent(in) :: sqrts end subroutine event_expr_setup_vars <>= module 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 expr%var_list%append_string_ptr (var_str ("$process_id"), & expr%id, is_known = expr%has_id, & locked = .true., verbose = .false., intrinsic = .true.) call expr%var_list%append_int_ptr (var_str ("process_num_id"), & expr%num_id, is_known = expr%has_num_id, & locked = .true., verbose = .false., intrinsic = .true.) call expr%var_list%append_real_ptr (var_str ("sqme"), & expr%sqme_prc, is_known = expr%has_sqme_prc, & locked = .true., verbose = .false., intrinsic = .true.) call expr%var_list%append_real_ptr (var_str ("sqme_ref"), & expr%sqme_ref, is_known = expr%has_sqme_ref, & locked = .true., verbose = .false., intrinsic = .true.) call expr%var_list%append_int_ptr (var_str ("event_index"), & expr%index, is_known = expr%has_index, & locked = .true., verbose = .false., intrinsic = .true.) call expr%var_list%append_real_ptr (var_str ("event_weight"), & expr%weight_prc, is_known = expr%has_weight_prc, & locked = .true., verbose = .false., intrinsic = .true.) call expr%var_list%append_real_ptr (var_str ("event_weight_ref"), & expr%weight_ref, is_known = expr%has_weight_ref, & locked = .true., verbose = .false., intrinsic = .true.) call expr%var_list%append_real_ptr (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. <>= procedure :: setup_analysis => event_expr_setup_analysis <>= module subroutine event_expr_setup_analysis (expr, ef_analysis) class(event_expr_t), intent(inout), target :: expr class(expr_factory_t), intent(in) :: ef_analysis end subroutine event_expr_setup_analysis <>= module 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. <>= procedure :: setup_reweight => event_expr_setup_reweight <>= module subroutine event_expr_setup_reweight (expr, ef_reweight) class(event_expr_t), intent(inout), target :: expr class(expr_factory_t), intent(in) :: ef_reweight end subroutine event_expr_setup_reweight <>= module 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. <>= procedure :: set_process_id => event_expr_set_process_id procedure :: set_process_num_id => event_expr_set_process_num_id <>= module subroutine event_expr_set_process_id (expr, id) class(event_expr_t), intent(inout) :: expr type(string_t), intent(in) :: id end subroutine event_expr_set_process_id module subroutine event_expr_set_process_num_id (expr, num_id) class(event_expr_t), intent(inout) :: expr integer, intent(in) :: num_id end subroutine event_expr_set_process_num_id <>= module 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 module 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. <>= procedure :: reset_contents => event_expr_reset_contents procedure :: set => event_expr_set <>= module subroutine event_expr_reset_contents (expr) class(event_expr_t), intent(inout) :: expr end subroutine event_expr_reset_contents module 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 end subroutine event_expr_set <>= module 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 module 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. <>= procedure :: has_event_index => event_expr_has_event_index procedure :: get_event_index => event_expr_get_event_index <>= module function event_expr_has_event_index (expr) result (flag) class(event_expr_t), intent(in) :: expr logical :: flag end function event_expr_has_event_index module function event_expr_get_event_index (expr) result (index) class(event_expr_t), intent(in) :: expr integer :: index end function event_expr_get_event_index <>= module 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 module 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. <>= 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 <>= module subroutine event_expr_set_event_index (expr, index) class(event_expr_t), intent(inout) :: expr integer, intent(in) :: index end subroutine event_expr_set_event_index module subroutine event_expr_reset_event_index (expr) class(event_expr_t), intent(inout) :: expr end subroutine event_expr_reset_event_index module subroutine event_expr_increment_event_index (expr, offset) class(event_expr_t), intent(inout) :: expr integer, intent(in), optional :: offset end subroutine event_expr_increment_event_index <>= module 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 module 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 module 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. <>= procedure :: fill_subevt => event_expr_fill_subevt <>= module subroutine event_expr_fill_subevt (expr, particle_set) class(event_expr_t), intent(inout) :: expr type(particle_set_t), intent(in) :: particle_set end subroutine event_expr_fill_subevt <>= module 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, expr%colorize_subevt) expr%sqrts_hat = expr%get_sqrts_hat () expr%n_in = expr%get_n_in () expr%n_out = expr%get_n_out () 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. <>= procedure :: evaluate => event_expr_evaluate <>= module 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 end subroutine event_expr_evaluate <>= module 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. 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]]>>= <> module parton_states <> use variables use expr_base use model_data use flavors use quantum_numbers use state_matrices use interactions use evaluators use beams use sf_base use prc_core use subevt_expr <> <> <> interface <> end interface end module parton_states @ %def parton_states @ <<[[parton_states_sub.f90]]>>= <> submodule (parton_states) parton_states_s <> use io_units use format_utils, only: write_separator use diagnostics use lorentz use subevents use helicities use colors use polarizations use process_constants implicit none contains <> end submodule parton_states_s @ %def parton_states_s @ \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). <>= 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 <> 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 are 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]]. <>= public :: isolated_state_t <>= 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 <> 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]]. <>= public :: connected_state_t <>= 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 <> 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. <>= procedure :: write => parton_state_write <>= module subroutine parton_state_write (state, unit, testflag) class(parton_state_t), intent(in) :: state integer, intent(in), optional :: unit logical, intent(in), optional :: testflag end subroutine parton_state_write <>= module 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. <>= procedure :: final => parton_state_final <>= module subroutine parton_state_final (state) class(parton_state_t), intent(inout) :: state end subroutine parton_state_final <>= module 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. <>= procedure :: init => isolated_state_init <>= module 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 end subroutine isolated_state_init <>= module 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. <>= procedure :: setup_square_trace => isolated_state_setup_square_trace <>= module 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 integer, intent(in), dimension(:), allocatable :: col logical, intent(in) :: keep_fs_flavor end subroutine isolated_state_setup_square_trace <>= module 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 for 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 @ Set up an identity-evaluator for the trace. This implies that [[me]] is considered to be a squared amplitude, as for example for BLHA matrix elements. <>= procedure :: setup_identity_trace => isolated_state_setup_identity_trace <>= module 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 end subroutine isolated_state_setup_identity_trace <>= module 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 @ Set up 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. <>= procedure :: setup_square_matrix => isolated_state_setup_square_matrix <>= module 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 end subroutine isolated_state_setup_square_matrix <>= module 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. <>= procedure :: setup_square_flows => isolated_state_setup_square_flows <>= module 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 end subroutine isolated_state_setup_square_flows <>= module 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} Set up 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. If an extended structure function is required [[requires_extended_sf]], we have to not consider [[sub]] as a quantum number. <>= procedure :: setup_connected_trace => connected_state_setup_connected_trace <>= module subroutine connected_state_setup_connected_trace & (state, isolated, int, resonant, undo_helicities, & keep_fs_flavors, requires_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 :: requires_extended_sf end subroutine connected_state_setup_connected_trace <>= module subroutine connected_state_setup_connected_trace & (state, isolated, int, resonant, undo_helicities, & keep_fs_flavors, requires_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 :: requires_extended_sf type(quantum_numbers_mask_t) :: mask type(interaction_t), pointer :: src_int, beam_int logical :: reduce, fs_flv_flag if (debug_on) 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_for_qn = requires_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 undo_qn_hel (src_int, mask, src_int%get_n_tot ()) call beam_int%set_matrix_element (cmplx (1, 0, default)) call src_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 @ Set up 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. <>= procedure :: setup_connected_matrix => connected_state_setup_connected_matrix <>= module 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 end subroutine connected_state_setup_connected_matrix <>= module 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 @ Set up 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. For fixed-order NLO differential distribution, we are interested at the partonic level, no parton showering takes place as this would demand for a proper matching. So, the flows in the [[connected_state]] are not needed, and the color part will be masked for the interaction coming from the [[sf_chain]]. The squared matrix elements coming from the OLP provider at the moment do not come with flows anyhow. This needs to be revised once the matching to the shower is completed. <>= procedure :: setup_connected_flows => connected_state_setup_connected_flows <>= module subroutine connected_state_setup_connected_flows & (state, isolated, int, resonant, qn_filter_conn, mask_color) 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, mask_color type(quantum_numbers_t), intent(in), optional :: qn_filter_conn end subroutine connected_state_setup_connected_flows <>= module subroutine connected_state_setup_connected_flows & (state, isolated, int, resonant, qn_filter_conn, mask_color) 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, mask_color type(quantum_numbers_t), intent(in), optional :: qn_filter_conn type(quantum_numbers_mask_t) :: mask type(quantum_numbers_mask_t), dimension(:), allocatable :: mask_sf type(interaction_t), pointer :: src_int logical :: mask_c mask_c = .false. if (present (mask_color)) mask_c = mask_color 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 if (mask_c) then allocate (mask_sf (src_int%get_n_tot ())) mask_sf = quantum_numbers_mask (.false., .true., .false.) call src_int%reduce_state_matrix (mask_sf, keep_order = .true.) end if 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. <>= procedure :: setup_state_flv => connected_state_setup_state_flv <>= module subroutine connected_state_setup_state_flv (state, n_out_hard) class(connected_state_t), intent(inout), target :: state integer, intent(in) :: n_out_hard end subroutine connected_state_setup_state_flv <>= module 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 state%matrix%get_flv_content (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. <>= procedure :: get_state_flv => connected_state_get_state_flv <>= module function connected_state_get_state_flv (state) result (state_flv) class(connected_state_t), intent(in) :: state type(state_flv_content_t) :: state_flv end function connected_state_get_state_flv <>= module 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. <>= procedure :: setup_subevt => connected_state_setup_subevt <>= module 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 end subroutine connected_state_setup_subevt <>= module 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 <>= procedure :: renew_flv_content_subevt => & connected_state_renew_flv_content_subevt <>= module subroutine connected_state_renew_flv_content_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 end subroutine connected_state_renew_flv_content_subevt <>= module subroutine connected_state_renew_flv_content_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%renew_flv_content_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_renew_flv_content_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. <>= procedure :: setup_var_list => connected_state_setup_var_list <>= module 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 end subroutine connected_state_setup_var_list <>= module 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. <>= 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 <>= module subroutine connected_state_setup_cuts (state, ef_cuts) class(connected_state_t), intent(inout), target :: state class(expr_factory_t), intent(in) :: ef_cuts end subroutine connected_state_setup_cuts module subroutine connected_state_setup_scale (state, ef_scale) class(connected_state_t), intent(inout), target :: state class(expr_factory_t), intent(in) :: ef_scale end subroutine connected_state_setup_scale module 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 end subroutine connected_state_setup_fac_scale module 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 end subroutine connected_state_setup_ren_scale module subroutine connected_state_setup_weight (state, ef_weight) class(connected_state_t), intent(inout), target :: state class(expr_factory_t), intent(in) :: ef_weight end subroutine connected_state_setup_weight <>= module 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 module 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 module 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 module 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 module 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. <>= procedure :: reset_expressions => connected_state_reset_expressions <>= module subroutine connected_state_reset_expressions (state) class(connected_state_t), intent(inout) :: state end subroutine connected_state_reset_expressions <>= module 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]]. <>= procedure :: receive_kinematics => parton_state_receive_kinematics <>= module subroutine parton_state_receive_kinematics (state) class(parton_state_t), intent(inout), target :: state end subroutine parton_state_receive_kinematics <>= module 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. <>= procedure :: send_kinematics => parton_state_send_kinematics <>= module subroutine parton_state_send_kinematics (state) class(parton_state_t), intent(inout), target :: state end subroutine parton_state_send_kinematics <>= module subroutine parton_state_send_kinematics (state) class(parton_state_t), intent(inout), target :: state if (state%has_trace) then call state%trace%send_momenta () 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. <>= procedure :: evaluate_expressions => connected_state_evaluate_expressions <>= module 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, weight real(default), intent(out), allocatable :: fac_scale, ren_scale real(default), intent(in), allocatable, optional :: scale_forced logical, intent(in), optional :: force_evaluation end subroutine connected_state_evaluate_expressions <>= module 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, weight real(default), intent(out), allocatable :: fac_scale, ren_scale 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. <>= procedure :: evaluate_sf_chain => isolated_state_evaluate_sf_chain <>= module subroutine isolated_state_evaluate_sf_chain (state, fac_scale) class(isolated_state_t), intent(inout) :: state real(default), intent(in) :: fac_scale end subroutine isolated_state_evaluate_sf_chain <>= module 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. <>= procedure :: evaluate_trace => parton_state_evaluate_trace <>= module subroutine parton_state_evaluate_trace (state) class(parton_state_t), intent(inout) :: state end subroutine parton_state_evaluate_trace <>= module 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 <>= procedure :: evaluate_matrix => parton_state_evaluate_matrix <>= module subroutine parton_state_evaluate_matrix (state) class(parton_state_t), intent(inout) :: state end subroutine parton_state_evaluate_matrix <>= module 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. <>= procedure :: evaluate_event_data => parton_state_evaluate_event_data <>= module subroutine parton_state_evaluate_event_data (state, only_momenta) class(parton_state_t), intent(inout) :: state logical, intent(in), optional :: only_momenta end subroutine parton_state_evaluate_event_data <>= module 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. <>= procedure :: normalize_matrix_by_trace => & parton_state_normalize_matrix_by_trace <>= module subroutine parton_state_normalize_matrix_by_trace (state) class(parton_state_t), intent(inout) :: state end subroutine parton_state_normalize_matrix_by_trace <>= module 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. <>= 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 <>= module function parton_state_get_trace_int_ptr (state) result (ptr) class(parton_state_t), intent(in), target :: state type(interaction_t), pointer :: ptr end function parton_state_get_trace_int_ptr module function parton_state_get_matrix_int_ptr (state) result (ptr) class(parton_state_t), intent(in), target :: state type(interaction_t), pointer :: ptr end function parton_state_get_matrix_int_ptr module function parton_state_get_flows_int_ptr (state) result (ptr) class(parton_state_t), intent(in), target :: state type(interaction_t), pointer :: ptr end function parton_state_get_flows_int_ptr <>= module 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 module 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 module 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. <>= procedure :: get_beam_index => connected_state_get_beam_index procedure :: get_in_index => connected_state_get_in_index <>= module subroutine connected_state_get_beam_index (state, i_beam) class(connected_state_t), intent(in) :: state integer, dimension(:), intent(out) :: i_beam end subroutine connected_state_get_beam_index module subroutine connected_state_get_in_index (state, i_in) class(connected_state_t), intent(in) :: state integer, dimension(:), intent(out) :: i_in end subroutine connected_state_get_in_index <>= module 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 module 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 @ <>= public :: refill_evaluator <>= module 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 end subroutine refill_evaluator <>= module 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. <>= procedure :: get_n_out => parton_state_get_n_out <>= module function parton_state_get_n_out (state) result (n) class(parton_state_t), intent(in), target :: state integer :: n end function parton_state_get_n_out <>= module 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]]>>= <> module parton_states_ut use unit_tests use parton_states_uti <> <> contains <> end module parton_states_ut @ %def parton_states_ut <<[[parton_states_uti.f90]]>>= <> module parton_states_uti <> <> 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 <> <> contains <> end module parton_states_uti @ %def parton_states_uti @ <>= public :: parton_states_test <>= subroutine parton_states_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> end subroutine parton_states_test @ %def parton_states_test @ \subsubsection{Test a simple isolated state} <>= call test (parton_states_1, "parton_states_1", & "Create a 2 -> 2 isolated state and compute trace", & u, results) <>= public :: parton_states_1 <>= 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 !!! Do not 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]]>>= <> module pcm_base <> <> use os_interface, only: os_data_t use process_libraries, only: process_library_t use prc_core_def use prc_core use variables, only: var_list_t use mappings, only: mapping_defaults_t use phs_base, only: phs_config_t use phs_forests, only: phs_parameters_t use mci_base, only: mci_t use model_data, only: model_data_t use models, only: model_t use blha_config, only: blha_master_t use blha_olp_interfaces, only: blha_template_t use process_config use process_mci, only: process_mci_entry_t <> <> <> <> <> interface <> end interface end module pcm_base @ %def pcm_base @ <<[[pcm_base_sub.f90]]>>= <> submodule (pcm_base) pcm_base_s use io_units use diagnostics use format_utils, only: write_integer_array use format_utils, only: write_separator use physics_defs, only: BORN, NLO_REAL implicit none contains <> end submodule pcm_base_s @ %def pcm_base_s @ \subsection{Core management} This object holds information about the cores used by the components and allocates the corresponding manager instance. [[i_component]] is the index of the process component which this core belongs to. The pointer to the core definition is a convenient help in configuring the core itself. We allow for a [[blha_config]] configuration object that covers BLHA cores. The BLHA standard is suitable generic to warrant support outside of specific type extension (i.e., applies to LO and NLO if requested). The BLHA configuration is allocated only if the core requires it. <>= public :: core_entry_t <>= type :: core_entry_t integer :: i_component = 0 logical :: active = .false. class(prc_core_def_t), pointer :: core_def => null () type(blha_template_t), allocatable :: blha_config class(prc_core_t), allocatable :: core contains <> end type core_entry_t @ %def core_entry_t @ <>= procedure :: get_core_ptr => core_entry_get_core_ptr <>= module function core_entry_get_core_ptr (core_entry) result (core) class(core_entry_t), intent(in), target :: core_entry class(prc_core_t), pointer :: core end function core_entry_get_core_ptr <>= module function core_entry_get_core_ptr (core_entry) result (core) class(core_entry_t), intent(in), target :: core_entry class(prc_core_t), pointer :: core if (allocated (core_entry%core)) then core => core_entry%core else core => null () end if end function core_entry_get_core_ptr @ %def core_entry_get_core_ptr @ Configure the core object after allocation with correct type. The [[core_def]] object pointer and the index [[i_component]] of the associated process component are already there. <>= procedure :: configure => core_entry_configure <>= module subroutine core_entry_configure (core_entry, lib, id) class(core_entry_t), intent(inout) :: core_entry type(process_library_t), intent(in), target :: lib type(string_t), intent(in) :: id end subroutine core_entry_configure <>= module subroutine core_entry_configure (core_entry, lib, id) class(core_entry_t), intent(inout) :: core_entry type(process_library_t), intent(in), target :: lib type(string_t), intent(in) :: id call core_entry%core%init & (core_entry%core_def, lib, id, core_entry%i_component) end subroutine core_entry_configure @ %def core_entry_configure @ \subsection{Process component manager} The process-component manager [[pcm]] is the master component of the [[process_t]] object. It serves two purposes: \begin{enumerate} \item It holds configuration data which allow us to centrally manage the components, terms, etc.\ of the process object. \item It implements the methods that realize the algorithm for constructing the process object and computing an integral. This algorithm makes use of the data stored within [[pcm]]. \end{enumerate} To this end, the object is abstract and polymorphic. The two extensions that we support, implement (a) default tree-level calculation, optionally including a sum over sub-processes with different particle content, or (b) the FKS-NLO subtraction algorithm for QCD-corrected processes. In both cases, the type extensions may hold suitable further data. Data included in the base type: The number of components determines the [[component_selected]] array. [[i_phs_config]] is a lookup table that holds the PHS configuration index for a given component index. [[i_core]] is a lookup table that holds the core-entry index for a given component index. [[i_mci]] is a lookup table that holds the integrator (MCI) index for a given component index. <>= public :: pcm_t <>= type, abstract :: pcm_t logical :: initialized = .false. logical :: has_pdfs = .false. integer :: n_components = 0 integer :: n_cores = 0 integer :: n_mci = 0 logical, dimension(:), allocatable :: component_selected logical, dimension(:), allocatable :: component_active integer, dimension(:), allocatable :: i_phs_config integer, dimension(:), allocatable :: i_core integer, dimension(:), allocatable :: i_mci type(blha_template_t) :: blha_defaults logical :: uses_blha = .false. type(os_data_t) :: os_data contains <> end type pcm_t @ %def pcm_t @ The factory method. We use the [[inout]] intent, so calling this again is an error. <>= procedure(pcm_allocate_workspace), deferred :: allocate_workspace <>= abstract interface subroutine pcm_allocate_workspace (pcm, work) import class(pcm_t), intent(in) :: pcm class(pcm_workspace_t), intent(inout), allocatable :: work end subroutine pcm_allocate_workspace end interface @ %def pcm_allocate_workspace @ <>= procedure(pcm_is_nlo), deferred :: is_nlo <>= 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 @ <>= procedure(pcm_final), deferred :: final <>= abstract interface subroutine pcm_final (pcm) import class(pcm_t), intent(inout) :: pcm end subroutine pcm_final end interface @ %def pcm_final @ \subsection{Initialization methods} The PCM has the duty to coordinate and configure the process-object components. Initialize the PCM configuration itself, using environment data. <>= procedure(pcm_init), deferred :: init <>= abstract interface subroutine pcm_init (pcm, env, meta) import class(pcm_t), intent(out) :: pcm type(process_environment_t), intent(in) :: env type(process_metadata_t), intent(in) :: meta end subroutine pcm_init end interface @ %def pcm_init @ Initialize the BLHA configuration block, the component-independent default settings. This is to be called by [[pcm_init]]. We use the provided variable list. This block is filled regardless of whether BLHA is actually used, because why not? We use a default value for the scheme (not set in unit tests). <>= procedure :: set_blha_defaults => pcm_set_blha_defaults <>= module subroutine pcm_set_blha_defaults (pcm, polarized_beams, var_list) class(pcm_t), intent(inout) :: pcm type(var_list_t), intent(in) :: var_list logical, intent(in) :: polarized_beams end subroutine pcm_set_blha_defaults <>= module subroutine pcm_set_blha_defaults (pcm, polarized_beams, var_list) class(pcm_t), intent(inout) :: pcm type(var_list_t), intent(in) :: var_list logical, intent(in) :: polarized_beams logical :: muon_yukawa_off real(default) :: top_yukawa type(string_t) :: ew_scheme muon_yukawa_off = & var_list%get_lval (var_str ("?openloops_switch_off_muon_yukawa")) top_yukawa = & var_list%get_rval (var_str ("blha_top_yukawa")) ew_scheme = & var_list%get_sval (var_str ("$blha_ew_scheme")) if (ew_scheme == "") ew_scheme = "Gmu" call pcm%blha_defaults%init & (polarized_beams, muon_yukawa_off, top_yukawa, ew_scheme) end subroutine pcm_set_blha_defaults @ %def pcm_set_blha_defaults @ Read the method settings from the variable list and store them in the BLHA master. The details depend on the [[pcm]] concrete type. <>= procedure(pcm_set_blha_methods), deferred :: set_blha_methods <>= abstract interface subroutine pcm_set_blha_methods (pcm, blha_master, var_list) import class(pcm_t), intent(inout) :: pcm type(blha_master_t), intent(inout) :: blha_master type(var_list_t), intent(in) :: var_list end subroutine pcm_set_blha_methods end interface @ %def pcm_set_blha_methods @ Produce the LO and NLO flavor-state tables (as far as available), as appropriate for BLHA configuration. We may inspect either the PCM itself or the array of process cores. <>= procedure(pcm_get_blha_flv_states), deferred :: get_blha_flv_states <>= abstract interface subroutine pcm_get_blha_flv_states (pcm, core_entry, flv_born, flv_real) import class(pcm_t), intent(in) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry integer, dimension(:,:), allocatable, intent(out) :: flv_born integer, dimension(:,:), allocatable, intent(out) :: flv_real end subroutine pcm_get_blha_flv_states end interface @ %def pcm_get_blha_flv_states @ Allocate the right number of process components. The number is also stored in the process meta. Initially, all components are active but none are selected. <>= procedure :: allocate_components => pcm_allocate_components <>= module subroutine pcm_allocate_components (pcm, comp, meta) class(pcm_t), intent(inout) :: pcm type(process_component_t), dimension(:), allocatable, intent(out) :: comp type(process_metadata_t), intent(in) :: meta end subroutine pcm_allocate_components <>= module subroutine pcm_allocate_components (pcm, comp, meta) class(pcm_t), intent(inout) :: pcm type(process_component_t), dimension(:), allocatable, intent(out) :: comp type(process_metadata_t), intent(in) :: meta pcm%n_components = meta%n_components allocate (comp (pcm%n_components)) allocate (pcm%component_selected (pcm%n_components), source = .false.) allocate (pcm%component_active (pcm%n_components), source = .true.) end subroutine pcm_allocate_components @ %def pcm_allocate_components @ Each process component belongs to a category/type, which we identify by a universal integer constant. The categories can be taken from the process definition. For easy lookup, we store the categories in an array. <>= procedure(pcm_categorize_components), deferred :: categorize_components <>= abstract interface subroutine pcm_categorize_components (pcm, config) import class(pcm_t), intent(inout) :: pcm type(process_config_data_t), intent(in) :: config end subroutine pcm_categorize_components end interface @ %def pcm_categorize_components @ Allocate the right number and type(s) of process-core objects, i.e., the interface object between the process and matrix-element code. Within the [[pcm]] block, also associate cores with components and store relevant configuration data, including the [[i_core]] lookup table. <>= procedure(pcm_allocate_cores), deferred :: allocate_cores <>= abstract interface subroutine pcm_allocate_cores (pcm, config, core_entry) import class(pcm_t), intent(inout) :: pcm type(process_config_data_t), intent(in) :: config type(core_entry_t), dimension(:), allocatable, intent(out) :: core_entry end subroutine pcm_allocate_cores end interface @ %def pcm_allocate_cores @ Generate and interface external code for a single core, if this is required. <>= procedure(pcm_prepare_any_external_code), deferred :: & prepare_any_external_code <>= abstract interface subroutine pcm_prepare_any_external_code & (pcm, core_entry, i_core, libname, model, var_list) import class(pcm_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry integer, intent(in) :: i_core type(string_t), intent(in) :: libname type(model_data_t), intent(in), target :: model type(var_list_t), intent(in) :: var_list end subroutine pcm_prepare_any_external_code end interface @ %def pcm_prepare_any_external_code @ Prepare the BLHA configuration for a core object that requires it. This does not affect the core object, which may not yet be allocated. <>= procedure(pcm_setup_blha), deferred :: setup_blha <>= abstract interface subroutine pcm_setup_blha (pcm, core_entry) import class(pcm_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry end subroutine pcm_setup_blha end interface @ %def pcm_setup_blha @ Configure the BLHA interface for a core object that requires it. This is separate from the previous method, assuming that the [[pcm]] has to allocate the actual cores and acquire some data in-between. <>= procedure(pcm_prepare_blha_core), deferred :: prepare_blha_core <>= abstract interface subroutine pcm_prepare_blha_core (pcm, core_entry, model) import class(pcm_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry class(model_data_t), intent(in), target :: model end subroutine pcm_prepare_blha_core end interface @ %def pcm_prepare_blha_core @ Allocate and configure the MCI (multi-channel integrator) records and their relation to process components, appropriate for the algorithm implemented by [[pcm]]. Create a [[mci_t]] template: the procedure [[dispatch_mci]] is called as a factory method for allocating the [[mci_t]] object with a specific concrete type. The call may depend on the concrete [[pcm]] type. <>= public :: dispatch_mci_proc <>= abstract interface subroutine dispatch_mci_proc (mci, var_list, process_id, is_nlo) import class(mci_t), allocatable, intent(out) :: mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id logical, intent(in), optional :: is_nlo end subroutine dispatch_mci_proc end interface @ %def dispatch_mci_proc <>= procedure(pcm_setup_mci), deferred :: setup_mci procedure(pcm_call_dispatch_mci), deferred :: call_dispatch_mci <>= abstract interface subroutine pcm_setup_mci (pcm, mci_entry) import class(pcm_t), intent(inout) :: pcm type(process_mci_entry_t), & dimension(:), allocatable, intent(out) :: mci_entry end subroutine pcm_setup_mci end interface abstract interface subroutine pcm_call_dispatch_mci (pcm, & dispatch_mci, var_list, process_id, mci_template) import class(pcm_t), intent(inout) :: pcm procedure(dispatch_mci_proc) :: dispatch_mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id class(mci_t), intent(out), allocatable :: mci_template end subroutine pcm_call_dispatch_mci end interface @ %def pcm_setup_mci @ %def pcm_call_dispatch_mci @ Proceed with PCM configuration based on the core and component configuration data. Base version is empty. <>= procedure(pcm_complete_setup), deferred :: complete_setup <>= abstract interface subroutine pcm_complete_setup (pcm, core_entry, component, model) import class(pcm_t), intent(inout) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry type(process_component_t), dimension(:), intent(inout) :: component type(model_t), intent(in), target :: model end subroutine pcm_complete_setup end interface @ %def pcm_complete_setup @ \subsubsection{Retrieve information} Return the core index that belongs to a particular component. <>= procedure :: get_i_core => pcm_get_i_core <>= module function pcm_get_i_core (pcm, i_component) result (i_core) class(pcm_t), intent(in) :: pcm integer, intent(in) :: i_component integer :: i_core end function pcm_get_i_core <>= module function pcm_get_i_core (pcm, i_component) result (i_core) class(pcm_t), intent(in) :: pcm integer, intent(in) :: i_component integer :: i_core if (allocated (pcm%i_core)) then i_core = pcm%i_core(i_component) else i_core = 0 end if end function pcm_get_i_core @ %def pcm_get_i_core @ \subsubsection{Phase-space configuration} Allocate and initialize the right number and type(s) of phase-space configuration entries. The [[i_phs_config]] lookup table must be set accordingly. <>= procedure(pcm_init_phs_config), deferred :: init_phs_config <>= abstract interface subroutine pcm_init_phs_config & (pcm, phs_entry, meta, env, phs_par, mapping_defs) import class(pcm_t), intent(inout) :: pcm type(process_phs_config_t), & dimension(:), allocatable, intent(out) :: phs_entry type(process_metadata_t), intent(in) :: meta type(process_environment_t), intent(in) :: env type(mapping_defaults_t), intent(in) :: mapping_defs type(phs_parameters_t), intent(in) :: phs_par end subroutine pcm_init_phs_config end interface @ %def pcm_init_phs_config @ Initialize a single component. We require all process-configuration blocks, and specific templates for the phase-space and integrator configuration. We also provide the current component index [[i]] and the [[active]] flag. <>= procedure(pcm_init_component), deferred :: init_component <>= abstract interface subroutine pcm_init_component & (pcm, component, i, active, phs_config, env, meta, config) import class(pcm_t), intent(in) :: pcm type(process_component_t), intent(out) :: component integer, intent(in) :: i logical, intent(in) :: active class(phs_config_t), allocatable, intent(in) :: phs_config type(process_environment_t), intent(in) :: env type(process_metadata_t), intent(in) :: meta type(process_config_data_t), intent(in) :: config end subroutine pcm_init_component end interface @ %def pcm_init_component @ Record components in the process [[meta]] data if they have turned out to be inactive. <>= procedure :: record_inactive_components => pcm_record_inactive_components <>= module subroutine pcm_record_inactive_components (pcm, component, meta) class(pcm_t), intent(inout) :: pcm type(process_component_t), dimension(:), intent(in) :: component type(process_metadata_t), intent(inout) :: meta end subroutine pcm_record_inactive_components <>= module subroutine pcm_record_inactive_components (pcm, component, meta) class(pcm_t), intent(inout) :: pcm type(process_component_t), dimension(:), intent(in) :: component type(process_metadata_t), intent(inout) :: meta integer :: i pcm%component_active = component%active do i = 1, pcm%n_components if (.not. component(i)%active) call meta%deactivate_component (i) end do end subroutine pcm_record_inactive_components @ %def pcm_record_inactive_components @ \subsection{Manager workspace} This object deals with the actual (squared) matrix element values. It holds any central data that are generated and/or used when calculating a particular phase-space point. Since phase-space points are associated with an integrator, we expect the instances of this type to correspond to MCI instances. <>= public :: pcm_workspace_t <>= type, abstract :: pcm_workspace_t ! class(pcm_t), pointer :: config => null () logical :: bad_point = .false. contains <> end type pcm_workspace_t @ %def pcm_workspace_t @ <>= procedure(pcm_work_final), deferred :: final <>= abstract interface subroutine pcm_work_final (pcm_work) import class(pcm_workspace_t), intent(inout) :: pcm_work end subroutine pcm_work_final end interface @ %def pcm_work_final @ <>= procedure(pcm_work_is_nlo), deferred :: is_nlo <>= abstract interface function pcm_work_is_nlo (pcm_work) result (is_nlo) import logical :: is_nlo class(pcm_workspace_t), intent(inout) :: pcm_work end function pcm_work_is_nlo end interface @ %def pcm_work_is_nlo @ <>= procedure :: link_config => pcm_work_link_config <>= subroutine pcm_work_link_config (pcm_work, config) class(pcm_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in), target :: config pcm_work%config => config end subroutine pcm_work_link_config @ %def pcm_work_link_config @ <>= procedure :: is_valid => pcm_work_is_valid <>= module function pcm_work_is_valid (pcm_work) result (valid) logical :: valid class(pcm_workspace_t), intent(in) :: pcm_work end function pcm_work_is_valid <>= module function pcm_work_is_valid (pcm_work) result (valid) logical :: valid class(pcm_workspace_t), intent(in) :: pcm_work valid = .not. pcm_work%bad_point end function pcm_work_is_valid @ %def pcm_work_is_valid @ <>= procedure :: set_bad_point => pcm_work_set_bad_point <>= pure module subroutine pcm_work_set_bad_point (pcm_work, bad_point) class(pcm_workspace_t), intent(inout) :: pcm_work logical, intent(in) :: bad_point end subroutine pcm_work_set_bad_point <>= pure module subroutine pcm_work_set_bad_point (pcm_work, bad_point) class(pcm_workspace_t), intent(inout) :: pcm_work logical, intent(in) :: bad_point pcm_work%bad_point = pcm_work%bad_point .or. bad_point end subroutine pcm_work_set_bad_point @ %def pcm_work_set_bad_point @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{The process object} <<[[process.f90]]>>= <> module process <> <> <> use diagnostics use lorentz use rng_base use dispatch_rng, only: dispatch_rng_factory use dispatch_rng, only: update_rng_seed_in_var_list use os_interface use sm_qcd use mci_base use flavors use model_data use models use process_libraries use process_constants use variables use beam_structures use beams 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_def, only: prc_core_def_t use prc_core, only: prc_core_t, helicity_selection_t use phs_base use parton_states, only: connected_state_t use pcm_base use pcm use process_counter use process_config use process_mci <> <> <> <> interface <> end interface contains <> end module process @ %def process @ <<[[process_sub.f90]]>>= <> submodule (process) process_s use io_units use format_utils, only: write_separator use constants use numeric_utils use cputime use md5 use integration_results use physics_defs use interactions use particles use dispatch_phase_space, only: dispatch_phs use prc_external, only: prc_external_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_fks, only: phs_fks_config_t use mappings, only: mapping_defaults_t use phs_forests, only: phs_parameters_t use phs_wood, only: phs_wood_config_t use blha_config, only: blha_master_t implicit none contains <> end submodule process_s @ %def process_s @ \subsection{Process status} Store counter and status information in a process object. <>= type :: process_status_t private end type process_status_t @ %def process_status_t @ \subsection{Process status} Store integration results in a process object. <>= type :: process_results_t private end type process_results_t @ %def process_results_t @ \subsection{The process type} NOTE: The description below represents the intended structure after refactoring and disentangling the FKS-NLO vs. LO algorithm dependencies. A [[process]] object is the internal representation of integration-run methods and data, as they are controlled by the user via a Sindarin script. The process object provides access to matrix elements (the actual ``process'' definitions that the user has provided before), it defines the separation into individually integrable components, and it manages phase-space construction, the actual integration over phase space, and the accumulation of results. As a workspace for individual sampling calls, we introduce an associated [[process_instance]] object type elsewhere. The [[process]] object contains data that either define the configuration or accumulate results from a complete integration pass. After successful phase-space integration, subsequent event generation is not actually represented by the [[process]] object. However, any event generation refers to an existing [[process]] object which represents a specific integration pass, and it uses a fresh [[process_instance]] workspace for calculations. 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 [[meta]] object describes the process globally. All contents become fixed when the object is initialized. Similarly, the [[env]] component captures the (Sindarin) environment at the point where the process object is initialized. The [[config]] object holds physical and technical configuration data that are collected and derived from the environment during process initialization, and which are common to all process components. The [[pcm]] object (process-component manager) is polymorphic. This is an object which holds data which represent the process-object structure and breakdown, and it contains the methods that implement the algorithm of managing this structure, accumulating partial results, and finally collecting the pieces. Depending on the generic process type, the contents of [[pcm]] do vary. In particular, there is some base-type data content and a simple (default) extension which is designed for traditional \oMega\ matrix elements and tree-level integration, possibly with several sub-processes to sum over. The second extension is designed for the FKS phase-space and subtraction algorithm for NLO QCD, which interfaces external one-loop providers. The [[component]] subobjects are, first of all, interfaces to the original process-component definitions that have been provided by the user, which the program has already taken to produce matrix-element code and interfaces. The management of those components is deferred by [[pcm]], which contains the information that defines the role of each component. In particular, in the default (LO) version, process components correspond to distinct particle combinations which have been included in the original process definition. In the FKS-NLO version, the breakdown of a NLO process into Born, real, virtual, etc.\ components determines the setup. The [[phs_config]] subobjects hold data that allow and implement the construction of phase-space configurations. The type [[process_phs_config_t]] is a wrapper type around the concrete polymorphic [[phs_config_t]] object type, which manages phase-space construction, including some bookkeeping required for setting up multi-channel integration. In the LO case, we expect a separate entry for each independent sub-process. For the FKS-NLO algorithm, we expect several entries: a default-type entry which implements the underlying Born phase space, and additional entries which enable the construction of various real-radiation and subtraction kinematics configurations. A [[core_entry]] is the interface to existing matrix-element and interaction code. Depending on the process and its components, there may be various distinct matrix elements to compute. The [[mci_entry]] objects configure distinct MC input parameter sets and their associated (multi-channel) integrators. The [[rng_factory]] object is a single objects which constructs individual random-number generators for various tasks, in a uniform and well-defined way. The [[beam_config]] object describes the incoming particles, either the decay mother or the scattering beams. It also contains the spectrum- and structure-function setup, which has to interact with the phase-space and integrator facilities. The [[term]] subobjects break down the process in its smallest parts which appear in the calculation. For LO processes, the correspondence between terms and components is one-to-one. The FKS-NLO algorithm requires not just separation of Born, real, and virtual components but also subtraction terms, and a decomposition of the real phase space into singular regions. The general idea is that the integration results of distinct sets of terms are summed over to provide the results of individual components. This is also controlled by the [[pcm]] subobject. The [[process_status]] object is a bookkeeping device that allows us to query the status of an ongoing calculation. The [[process_results]] object collects the integration results for external use, including integration history information. <>= public :: process_t <>= type :: process_t private type(process_metadata_t) :: & meta type(process_environment_t) :: & env type(process_config_data_t) :: & config class(pcm_t), allocatable :: & pcm type(process_component_t), dimension(:), allocatable :: & component type(process_phs_config_t), dimension(:), allocatable :: & phs_entry type(core_entry_t), dimension(:), allocatable :: & core_entry type(process_mci_entry_t), dimension(:), allocatable :: & mci_entry class(rng_factory_t), allocatable :: & rng_factory type(process_beam_config_t) :: & beam_config type(process_term_t), dimension(:), allocatable :: & term type(process_status_t) :: & status type(process_results_t) :: & result contains <> end type process_t @ %def process_t @ \subsection{Process pointer} Wrapper type for storing pointers to process objects in arrays. <>= public :: process_ptr_t <>= type :: process_ptr_t type(process_t), pointer :: p => null () end type process_ptr_t @ %def process_ptr_t @ \subsection{Output} 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. The shorthand as a traditional TBP. <>= procedure :: write => process_write <>= module subroutine process_write (process, screen, unit, & show_os_data, show_var_list, show_rng, show_expressions, pacify) class(process_t), intent(in) :: process logical, intent(in) :: screen integer, intent(in), optional :: unit logical, intent(in), optional :: show_os_data logical, intent(in), optional :: show_var_list logical, intent(in), optional :: show_rng logical, intent(in), optional :: show_expressions logical, intent(in), optional :: pacify end subroutine process_write <>= module subroutine process_write (process, screen, unit, & show_os_data, show_var_list, show_rng, show_expressions, pacify) class(process_t), intent(in) :: process logical, intent(in) :: screen integer, intent(in), optional :: unit logical, intent(in), optional :: show_os_data logical, intent(in), optional :: show_var_list logical, intent(in), optional :: show_rng logical, intent(in), optional :: show_expressions logical, intent(in), optional :: pacify integer :: u, iostat character(0) :: iomsg integer, dimension(:), allocatable :: v_list u = given_output_unit (unit) allocate (v_list (0)) call set_flag (v_list, F_SHOW_OS_DATA, show_os_data) call set_flag (v_list, F_SHOW_VAR_LIST, show_var_list) call set_flag (v_list, F_SHOW_RNG, show_rng) call set_flag (v_list, F_SHOW_EXPRESSIONS, show_expressions) call set_flag (v_list, F_PACIFY, pacify) if (screen) then call process%write_formatted (u, "LISTDIRECTED", v_list, iostat, iomsg) else call process%write_formatted (u, "DT", v_list, iostat, iomsg) end if end subroutine process_write @ %def process_write @ Standard DTIO procedure with binding. For the particular application, the screen format is triggered by the [[LISTDIRECTED]] option for the [[iotype]] format editor string. The other options activate when the particular parameter value is found in [[v_list]]. NOTE: The DTIO [[generic]] binding is supported by gfortran since 7.0. TODO wk 2018: The default could be to show everything, and we should have separate switches for all major parts. Currently, there are only a few. <>= ! generic :: write (formatted) => write_formatted procedure :: write_formatted => process_write_formatted <>= module subroutine process_write_formatted (dtv, unit, iotype, & v_list, iostat, iomsg) class(process_t), intent(in) :: dtv integer, intent(in) :: unit character(*), intent(in) :: iotype integer, dimension(:), intent(in) :: v_list integer, intent(out) :: iostat character(*), intent(inout) :: iomsg end subroutine process_write_formatted <>= module subroutine process_write_formatted (dtv, unit, iotype, & v_list, iostat, iomsg) class(process_t), intent(in) :: dtv integer, intent(in) :: unit character(*), intent(in) :: iotype integer, dimension(:), intent(in) :: v_list integer, intent(out) :: iostat character(*), intent(inout) :: iomsg integer :: u logical :: screen logical :: var_list logical :: rng_factory logical :: expressions logical :: counters logical :: os_data logical :: model logical :: pacify integer :: i u = unit select case (iotype) case ("LISTDIRECTED") screen = .true. case default screen = .false. end select var_list = flagged (v_list, F_SHOW_VAR_LIST) rng_factory = flagged (v_list, F_SHOW_RNG, .true.) expressions = flagged (v_list, F_SHOW_EXPRESSIONS) counters = .true. os_data = flagged (v_list, F_SHOW_OS_DATA) model = .false. pacify = flagged (v_list, F_PACIFY) associate (process => dtv) 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, screen) if (var_list) then call process%env%write (u, show_var_list=var_list, & show_model=.false., show_lib=.false., & show_os_data=os_data) else if (.not. screen) then write (u, "(1x,A)") "Variable list: [not shown]" end if if (process%meta%type == PRC_UNKNOWN) then call write_separator (u, 2) return else if (screen) then return end if call write_separator (u) call process%config%write (u, counters, model, expressions) if (rng_factory) then if (allocated (process%rng_factory)) then call write_separator (u) call process%rng_factory%write (u) end if end if 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 associate iostat = 0 iomsg = "" end subroutine process_write_formatted @ %def process_write_formatted @ <>= procedure :: write_meta => process_write_meta <>= module subroutine process_write_meta (process, unit, testflag) class(process_t), intent(in) :: process integer, intent(in), optional :: unit logical, intent(in), optional :: testflag end subroutine process_write_meta <>= module 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%pcm%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. <>= procedure :: show => process_show <>= module subroutine process_show (object, unit, verbose) class(process_t), intent(in) :: object integer, intent(in), optional :: unit logical, intent(in), optional :: verbose end subroutine process_show <>= module 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 wk 2018 (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. <>= procedure :: final => process_final <>= module subroutine process_final (process) class(process_t), intent(inout) :: process end subroutine process_final <>= module subroutine process_final (process) class(process_t), intent(inout) :: process integer :: i call process%env%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 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 [[lib]] and the process identifier [[proc_id]] (string). We will fetch the current run ID from the variable list [[var_list]]. We collect all important data from the environment and store them in the appropriate places. OS data, model, and variable list are copied into [[env]] (true snapshot), also the process library (pointer only). The [[meta]] subobject is initialized with process ID and attributes taken from the process library. We initialize the [[config]] subobject with all data that are relevant for this run, using the settings from [[env]]. These data determine the MD5 sum for this run, which allows us to identify the setup and possibly skips in a later re-run. We also allocate and initialize the embedded RNG factory. We take the seed from the [[var_list]], and we should return the [[var_list]] to the caller with a new seed. Finally, we allocate the process component manager [[pcm]], which implements the chosen algorithm for process integration. The first task of the manager is to allocate the component array and to determine the component categories (e.g., Born/Virtual etc.). TODO wk 2018: The [[pcm]] dispatcher should be provided by the caller, if we eventually want to eliminate dependencies on concrete [[pcm_t]] extensions. Gfortran 7/8/9 bug, has to remain in the main module: <>= procedure :: init => process_init <>= subroutine process_init & (process, proc_id, lib, os_data, model, var_list, beam_structure) class(process_t), intent(out) :: process type(string_t), intent(in) :: proc_id type(process_library_t), intent(in), target :: lib type(os_data_t), intent(in) :: os_data class(model_t), intent(in), target :: model type(var_list_t), intent(inout), target, optional :: var_list type(beam_structure_t), intent(in), optional :: beam_structure integer :: next_rng_seed if (debug_on) call msg_debug (D_PROCESS_INTEGRATION, "process_init") associate & (meta => process%meta, env => process%env, config => process%config) call env%init & (model, lib, os_data, var_list, beam_structure) call meta%init & (proc_id, lib, env%get_var_list_ptr ()) call config%init & (meta, env) call dispatch_rng_factory & (process%rng_factory, env%get_var_list_ptr (), next_rng_seed) call update_rng_seed_in_var_list (var_list, next_rng_seed) call dispatch_pcm & (process%pcm, config%process_def%is_nlo ()) associate (pcm => process%pcm) call pcm%init (env, meta) call pcm%allocate_components (process%component, meta) call pcm%categorize_components (config) end associate end associate end subroutine process_init @ %def process_init @ \subsection{Process component manager} The [[pcm]] (read: process-component manager) takes the responsibility of steering the actual algorithm of configuration and integration. Depending on the concrete type, different algorithms can be implemented. The first version of this supports just two implementations: leading-order (tree-level) integration and event generation, and NLO (QCD/FKS subtraction). We thus can start with a single logical for steering the dispatcher. TODO wk 2018: Eventually, we may eliminate all references to the extensions of [[pcm_t]] from this module and therefore move this outside the module as well. Gfortran 7/8/9 bug, has to be in the main module: <>= subroutine dispatch_pcm (pcm, is_nlo) class(pcm_t), allocatable, intent(out) :: pcm logical, intent(in) :: is_nlo if (.not. is_nlo) then allocate (pcm_default_t :: pcm) else allocate (pcm_nlo_t :: pcm) end if end subroutine dispatch_pcm @ %def dispatch_pcm @ This step is performed after phase-space and core objects are done: collect all missing information and prepare the process component manager for the appropriate integration algorithm. <>= procedure :: complete_pcm_setup => process_complete_pcm_setup <>= module subroutine process_complete_pcm_setup (process) class(process_t), intent(inout) :: process end subroutine process_complete_pcm_setup <>= module subroutine process_complete_pcm_setup (process) class(process_t), intent(inout) :: process call process%pcm%complete_setup & (process%core_entry, process%component, process%env%get_model_ptr ()) end subroutine process_complete_pcm_setup @ %def process_complete_pcm_setup @ \subsection{Core management} Allocate cores (interface objects to matrix-element code). The [[dispatch_core]] procedure is taken as an argument, so we do not depend on the implementation, and thus on the specific core types. The [[helicity_selection]] object collects data that the matrix-element code needs for configuring the appropriate behavior. After the cores have been allocated, and assuming the phs initial configuration has been done before, we proceed with computing the [[pcm]] internal data. <>= procedure :: setup_cores => process_setup_cores <>= module subroutine process_setup_cores (process, dispatch_core, & helicity_selection, use_color_factors, has_beam_pol) class(process_t), intent(inout) :: process procedure(dispatch_core_proc) :: dispatch_core type(helicity_selection_t), intent(in), optional :: helicity_selection logical, intent(in), optional :: use_color_factors logical, intent(in), optional :: has_beam_pol end subroutine process_setup_cores <>= module subroutine process_setup_cores (process, dispatch_core, & helicity_selection, use_color_factors, has_beam_pol) class(process_t), intent(inout) :: process procedure(dispatch_core_proc) :: dispatch_core type(helicity_selection_t), intent(in), optional :: helicity_selection logical, intent(in), optional :: use_color_factors logical, intent(in), optional :: has_beam_pol integer :: i associate (pcm => process%pcm) call pcm%allocate_cores (process%config, process%core_entry) do i = 1, size (process%core_entry) call dispatch_core (process%core_entry(i)%core, & process%core_entry(i)%core_def, & process%config%model, & helicity_selection, & process%config%qcd, & use_color_factors, & has_beam_pol) call process%core_entry(i)%configure & (process%env%get_lib_ptr (), process%meta%id) if (process%core_entry(i)%core%uses_blha ()) then call pcm%setup_blha (process%core_entry(i)) end if end do end associate end subroutine process_setup_cores @ %def process_setup_cores <>= abstract interface subroutine dispatch_core_proc (core, core_def, model, & helicity_selection, qcd, use_color_factors, has_beam_pol) import class(prc_core_t), allocatable, intent(inout) :: core class(prc_core_def_t), intent(in) :: core_def class(model_data_t), intent(in), target, optional :: model type(helicity_selection_t), intent(in), optional :: helicity_selection type(qcd_t), intent(in), optional :: qcd logical, intent(in), optional :: use_color_factors logical, intent(in), optional :: has_beam_pol end subroutine dispatch_core_proc end interface @ %def dispatch_core_proc @ Use the [[pcm]] to initialize the BLHA interface for each core which requires it. <>= procedure :: prepare_blha_cores => process_prepare_blha_cores <>= module subroutine process_prepare_blha_cores (process) class(process_t), intent(inout), target :: process end subroutine process_prepare_blha_cores <>= module subroutine process_prepare_blha_cores (process) class(process_t), intent(inout), target :: process integer :: i associate (pcm => process%pcm) do i = 1, size (process%core_entry) associate (core_entry => process%core_entry(i)) if (core_entry%core%uses_blha ()) then pcm%uses_blha = .true. call pcm%prepare_blha_core (core_entry, process%config%model) end if end associate end do end associate end subroutine process_prepare_blha_cores @ %def process_prepare_blha_cores @ Create the BLHA interface data, using PCM for specific data, and write the BLHA contract file(s). We take various configuration data and copy them to the [[blha_master]] record, which then creates and writes the contracts. For assigning the QCD/EW coupling powers, we inspect the first process component only. The other parameters are taken as-is from the process environment variables. <>= procedure :: create_blha_interface => process_create_blha_interface <>= module subroutine process_create_blha_interface (process) class(process_t), intent(inout) :: process end subroutine process_create_blha_interface <>= module subroutine process_create_blha_interface (process) class(process_t), intent(inout) :: process integer :: alpha_power, alphas_power integer :: openloops_phs_tolerance, openloops_stability_log logical :: use_cms type(string_t) :: ew_scheme, correction_type type(string_t) :: openloops_extra_cmd, openloops_allowed_libs type(blha_master_t) :: blha_master integer, dimension(:,:), allocatable :: flv_born, flv_real if (process%pcm%uses_blha) then call collect_configuration_parameters (process%get_var_list_ptr ()) call process%component(1)%config%get_coupling_powers & (alpha_power, alphas_power) associate (pcm => process%pcm) call pcm%set_blha_methods (blha_master, process%get_var_list_ptr ()) call blha_master%set_ew_scheme (ew_scheme) 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, & extra_cmd = openloops_extra_cmd, & allowed_libs = openloops_allowed_libs, & beam_structure = process%env%get_beam_structure ()) call pcm%get_blha_flv_states (process%core_entry, flv_born, flv_real) call blha_master%set_photon_characteristics (flv_born, process%config%n_in) call blha_master%generate (process%meta%id, & process%config%model, process%config%n_in, & alpha_power, alphas_power, & flv_born, flv_real) call blha_master%write_olp (process%meta%id) end associate end if contains subroutine collect_configuration_parameters (var_list) type(var_list_t), intent(in) :: 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")) use_cms = & var_list%get_lval (var_str ("?openloops_use_cms")) ew_scheme = & var_list%get_sval (var_str ("$blha_ew_scheme")) correction_type = & var_list%get_sval (var_str ("$nlo_correction_type")) openloops_extra_cmd = & var_list%get_sval (var_str ("$openloops_extra_cmd")) openloops_allowed_libs = & var_list%get_sval (var_str ("$openloops_allowed_libs")) end subroutine collect_configuration_parameters end subroutine process_create_blha_interface @ %def process_create_blha_interface @ Initialize the process components, one by one. We require templates for the [[mci]] (integrator) and [[phs_config]] (phase-space) configuration data. The [[active]] flag is set if the component has an associated matrix element, so we can compute it. The case of no core is a unit-test case. The specifics depend on the algorithm and are delegated to the [[pcm]] process-component manager. The optional [[phs_config]] overrides a pre-generated config array (for unit test). <>= procedure :: init_components => process_init_components <>= module subroutine process_init_components (process, phs_config) class(process_t), intent(inout), target :: process class(phs_config_t), allocatable, intent(in), optional :: phs_config end subroutine process_init_components <>= module subroutine process_init_components (process, phs_config) class(process_t), intent(inout), target :: process class(phs_config_t), allocatable, intent(in), optional :: phs_config integer :: i, i_core class(prc_core_t), pointer :: core logical :: active associate (pcm => process%pcm) do i = 1, pcm%n_components i_core = pcm%get_i_core(i) if (i_core > 0) then core => process%get_core_ptr (i_core) active = core%has_matrix_element () else active = .true. end if select type (pcm => process%pcm) type is (pcm_nlo_t) if (pcm%use_real_partition .and. .not. pcm%use_real_singular) then if (pcm%component_type(i) == COMP_REAL_SING) then active = .false. end if end if end select if (present (phs_config)) then call pcm%init_component (process%component(i), & i, & active, & phs_config, & process%env, process%meta, process%config) else call pcm%init_component (process%component(i), & i, & active, & process%phs_entry(pcm%i_phs_config(i))%phs_config, & process%env, process%meta, process%config) end if end do end associate end subroutine process_init_components @ %def process_init_components @ If process components have turned out to be inactive, this has to be recorded in the [[meta]] block. Delegate to the [[pcm]]. <>= procedure :: record_inactive_components => process_record_inactive_components <>= module subroutine process_record_inactive_components (process) class(process_t), intent(inout) :: process end subroutine process_record_inactive_components <>= module subroutine process_record_inactive_components (process) class(process_t), intent(inout) :: process associate (pcm => process%pcm) call pcm%record_inactive_components (process%component, process%meta) end associate end subroutine process_record_inactive_components @ %def process_record_inactive_components @ Determine the process terms for each process component. <>= procedure :: setup_terms => process_setup_terms <>= module subroutine process_setup_terms (process, with_beams) class(process_t), intent(inout), target :: process logical, intent(in), optional :: with_beams end subroutine process_setup_terms <>= module 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 logical :: requires_spin_correlations integer :: nlo_type_to_fetch, n_emitters 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 (pcm%component_type(i) /= 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 () if (debug_on) 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) select type (pcm => process%pcm) type is (pcm_nlo_t) singular_real = component%get_nlo_type () == NLO_REAL & .and. pcm%component_type(i) /= COMP_REAL_FIN class default singular_real = .false. end select 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 if (setup_subtraction_component) then select type (pcm => process%pcm) class is (pcm_nlo_t) process%term(i_term)%i_core = pcm%i_core(pcm%i_sub) end select else process%term(i_term)%i_core = process%pcm%get_i_core(i) end if 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) if (i_sub > 0) then select type (pcm => process%pcm) type is (pcm_nlo_t) requires_spin_correlations = & pcm%region_data%requires_spin_correlations () n_emitters = pcm%region_data%get_n_emitters_sc () class default requires_spin_correlations = .false. n_emitters = 0 end select if (requires_spin_correlations) then 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, & has_pdfs = process%pcm%has_pdfs, & n_emitters = n_emitters) 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, & subtraction_method = subtraction_method, & has_pdfs = process%pcm%has_pdfs) end if 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, & has_pdfs = process%pcm%has_pdfs) end if end do end associate k = k + n_entry(i) end do process%config%n_terms = n_tot 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. <>= procedure :: setup_beams_sqrts => process_setup_beams_sqrts <>= module 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 end subroutine process_setup_beams_sqrts <>= module 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 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%pcm%get_i_core (i) end if associate (core => process%core_entry(ic)%core) pdg_in(:,i) = core%data%get_pdg_in () end associate 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_in%get_length () == 1) .and. & all (pdg_in(1,:) == pdg_in(1,i0)) .and. & all (pdg_in(2,:) == pdg_in(2,i0))) then pdg_scattering(:) = pdg_in(:,i0)%get (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. <>= procedure :: setup_beams_decay => process_setup_beams_decay <>= module subroutine process_setup_beams_decay & (process, rest_frame, beam_structure, i_core) class(process_t), intent(inout), target :: process logical, intent(in), optional :: rest_frame type(beam_structure_t), intent(in), optional :: beam_structure integer, intent(in), optional :: i_core end subroutine process_setup_beams_decay <>= module subroutine process_setup_beams_decay & (process, rest_frame, beam_structure, i_core) class(process_t), intent(inout), target :: 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 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%pcm%get_i_core (i) end if associate (core => process%core_entry(ic)%core) pdg_in(:,i) = core%data%get_pdg_in () end associate 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_in%get_length () == 1) & .and. all (pdg_in(1,:) == pdg_in(1,i0))) then pdg_decay(:) = pdg_in(:,i0)%get (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. <>= procedure :: check_masses => process_check_masses <>= module subroutine process_check_masses (process) class(process_t), intent(in) :: process end subroutine process_check_masses <>= module 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 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 @ Set up index mapping for [[region_data]] for singular regions equivalent w.r.t. their amplitudes. Has to be called after [[region_data]] AND the [[core]] are fully set up. For processes with structure function, subprocesses which lead to the same amplitude for the hard interaction can differ if structure functions are applied. In this case we remap flavor structures to themselves if the eqvivalent hard interaction flavor structure has no identical initial state. <>= procedure :: optimize_nlo_singular_regions => & process_optimize_nlo_singular_regions <>= module subroutine process_optimize_nlo_singular_regions (process) class(process_t), intent(inout) :: process end subroutine process_optimize_nlo_singular_regions <>= module subroutine process_optimize_nlo_singular_regions (process) class(process_t), intent(inout) :: process class(prc_core_t), pointer :: core, core_sub integer, dimension(:), allocatable :: eqv_flv_index_born integer, dimension(:), allocatable :: eqv_flv_index_real integer, dimension(:,:), allocatable :: flv_born, flv_real integer :: i_flv, i_flv2, n_in, i integer :: i_component, i_core, i_core_sub logical :: fetched_born, fetched_real logical :: optimize fetched_born = .false.; fetched_real = .false. select type (pcm => process%pcm) type is (pcm_nlo_t) optimize = pcm%settings%reuse_amplitudes_fks if (optimize) then do i_component = 1, pcm%n_components i_core = pcm%get_i_core(i_component) core => process%get_core_ptr (i_core) if (.not. core%data_known) cycle associate (data => core%data) if (pcm%nlo_type_core(i_core) == NLO_REAL .and. & .not. pcm%component_type(i_component) == COMP_SUB) then if (allocated (core%data%eqv_flv_index)) then eqv_flv_index_real = core%get_equivalent_flv_index () fetched_real = .true. end if i_core_sub = pcm%get_i_core (pcm%i_sub) core_sub => process%get_core_ptr (i_core_sub) if (allocated (core_sub%data%eqv_flv_index)) then eqv_flv_index_born = core_sub%get_equivalent_flv_index () fetched_born = .true. end if if (fetched_born .and. fetched_real) exit end if end associate end do if (.not. fetched_born .or. .not. fetched_real) then call msg_warning('Failed to fetch flavor equivalence indices. & &Disabling singular region optimization') optimize = .false. eqv_flv_index_born = [(i, i = 1, pcm%region_data%n_flv_born)] eqv_flv_index_real = [(i, i = 1, pcm%region_data%n_flv_real)] end if if (optimize .and. pcm%has_pdfs) then flv_born = pcm%region_data%get_flv_states_born () flv_real = pcm%region_data%get_flv_states_real () n_in = pcm%region_data%n_in do i_flv = 1, size (eqv_flv_index_born) do i_flv2 = 1, i_flv if (any (flv_born(1:n_in, eqv_flv_index_born(i_flv)) /= & flv_born(1:n_in, i_flv))) then eqv_flv_index_born(i_flv) = i_flv exit end if end do end do do i_flv = 1, size (eqv_flv_index_real) do i_flv2 = 1, i_flv if (any (flv_real(1:n_in, eqv_flv_index_real(i_flv)) /= & flv_real(1:n_in, i_flv))) then eqv_flv_index_real(i_flv) = i_flv exit end if end do end do end if else eqv_flv_index_born = [(i, i = 1, pcm%region_data%n_flv_born)] eqv_flv_index_real = [(i, i = 1, pcm%region_data%n_flv_real)] end if pcm%region_data%eqv_flv_index_born = eqv_flv_index_born pcm%region_data%eqv_flv_index_real = eqv_flv_index_real call pcm%region_data%find_eqv_regions (optimize) end select end subroutine process_optimize_nlo_singular_regions @ %def process_optimize_nlo_singular_regions @ 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. <>= procedure :: get_pdg_in => process_get_pdg_in <>= module subroutine process_get_pdg_in (process, pdg_in) class(process_t), intent(in), target :: process type(pdg_array_t), dimension(:,:), allocatable, intent(out) :: pdg_in end subroutine process_get_pdg_in <>= module subroutine process_get_pdg_in (process, pdg_in) class(process_t), intent(in), target :: process type(pdg_array_t), dimension(:,:), allocatable, intent(out) :: pdg_in integer :: i, i_core 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%pcm%get_i_core (i) associate (core => process%core_entry(i_core)%core) pdg_in(:,i) = core%data%get_pdg_in () end associate end if end do end subroutine process_get_pdg_in @ %def process_get_pdg_in @ The phase-space configuration object, in case we need it separately. <>= procedure :: get_phs_config => process_get_phs_config <>= module 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 end function process_get_phs_config <>= module 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 if (process%component(i_component)%active) then phs_config => process%component(i_component)%phs_config else phs_config => null () end if 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. <>= procedure :: extract_resonance_history_set & => process_extract_resonance_history_set <>= module 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 end subroutine process_extract_resonance_history_set <>= module 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 if (process%component(i)%active) then 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 if end subroutine process_extract_resonance_history_set @ %def process_extract_resonance_history_set @ Initialize from a complete beam setup. If the beam setup does not apply directly to the process, choose a fallback option as a straight scattering or decay process. <>= procedure :: setup_beams_beam_structure => process_setup_beams_beam_structure <>= module 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 end subroutine process_setup_beams_beam_structure <>= module 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. <>= procedure :: beams_startup_message => process_beams_startup_message <>= module 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 end subroutine process_beams_startup_message <>= module 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 @ Initialize phase-space configuration by reading out the environment variables. We return the rebuild flags and store parameters in the blocks [[phs_par]] and [[mapping_defs]]. The phase-space configuration object(s) are allocated by [[pcm]]. <>= procedure :: init_phs_config => process_init_phs_config <>= module subroutine process_init_phs_config (process) class(process_t), intent(inout) :: process end subroutine process_init_phs_config <>= module subroutine process_init_phs_config (process) class(process_t), intent(inout) :: process type(var_list_t), pointer :: var_list type(phs_parameters_t) :: phs_par type(mapping_defaults_t) :: mapping_defs var_list => process%env%get_var_list_ptr () phs_par%m_threshold_s = & var_list%get_rval (var_str ("phs_threshold_s")) phs_par%m_threshold_t = & var_list%get_rval (var_str ("phs_threshold_t")) phs_par%off_shell = & var_list%get_ival (var_str ("phs_off_shell")) phs_par%keep_nonresonant = & var_list%get_lval (var_str ("?phs_keep_nonresonant")) phs_par%t_channel = & var_list%get_ival (var_str ("phs_t_channel")) mapping_defs%energy_scale = & var_list%get_rval (var_str ("phs_e_scale")) mapping_defs%invariant_mass_scale = & var_list%get_rval (var_str ("phs_m_scale")) mapping_defs%momentum_transfer_scale = & var_list%get_rval (var_str ("phs_q_scale")) mapping_defs%step_mapping = & var_list%get_lval (var_str ("?phs_step_mapping")) mapping_defs%step_mapping_exp = & var_list%get_lval (var_str ("?phs_step_mapping_exp")) mapping_defs%enable_s_mapping = & var_list%get_lval (var_str ("?phs_s_mapping")) associate (pcm => process%pcm) call pcm%init_phs_config (process%phs_entry, & process%meta, process%env, phs_par, mapping_defs) end associate end subroutine process_init_phs_config @ %def process_init_phs_config @ 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. <>= procedure :: configure_phs => process_configure_phs <>= module 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 end subroutine process_configure_phs <>= module 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, nlo_type 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) nlo_type = component%config%get_nlo_type () select case (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 (pcm%component_type(i) /= 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 if (combined_integration) then select type (phs_config => component%phs_config) class is (phs_wood_config_t) phs_config%is_combined_integration = .true. 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 @ <>= procedure :: print_phs_startup_message => process_print_phs_startup_message <>= module subroutine process_print_phs_startup_message (process) class(process_t), intent(in) :: process end subroutine process_print_phs_startup_message <>= module 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. <>= 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 <>= module 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 end subroutine process_init_sf_chain module 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 end subroutine process_set_sf_channel module subroutine process_set_sf_channel_array (process, sf_channel) class(process_t), intent(inout) :: process type(sf_channel_t), dimension(:), intent(in) :: sf_channel end subroutine process_set_sf_channel_array <>= module 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 module 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 module 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. <>= procedure :: sf_startup_message => process_sf_startup_message <>= module 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 end subroutine process_sf_startup_message <>= module 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. <>= procedure :: collect_channels => process_collect_channels <>= module subroutine process_collect_channels (process, coll) class(process_t), intent(inout) :: process type(phs_channel_collection_t), intent(inout) :: coll end subroutine process_collect_channels <>= module 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 does not contain phase-space parameters. Such a process can only be integrated if there are structure functions. <>= procedure :: contains_trivial_component => process_contains_trivial_component <>= module function process_contains_trivial_component (process) result (flag) class(process_t), intent(in) :: process logical :: flag end function process_contains_trivial_component <>= module 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 @ <>= procedure :: get_master_component => process_get_master_component <>= module 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 end function process_get_master_component <>= module 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. <>= procedure :: setup_mci => process_setup_mci <>= module subroutine process_setup_mci (process, dispatch_mci) class(process_t), intent(inout) :: process procedure(dispatch_mci_proc) :: dispatch_mci end subroutine process_setup_mci <>= module subroutine process_setup_mci (process, dispatch_mci) class(process_t), intent(inout) :: process procedure(dispatch_mci_proc) :: dispatch_mci class(mci_t), allocatable :: mci_template integer :: i, i_mci if (debug_on) call msg_debug (D_PROCESS_INTEGRATION, "process_setup_mci") associate (pcm => process%pcm) call pcm%call_dispatch_mci (dispatch_mci, & process%get_var_list_ptr (), process%meta%id, mci_template) call pcm%setup_mci (process%mci_entry) process%config%n_mci = pcm%n_mci process%component(:)%i_mci = pcm%i_mci(:) do i = 1, pcm%n_components i_mci = process%pcm%i_mci(i) if (i_mci > 0) then associate (component => process%component(i), & mci_entry => process%mci_entry(i_mci)) call mci_entry%configure (mci_template, & process%meta%type, & i_mci, i, component, process%beam_config%n_sfpar, & process%rng_factory) call mci_entry%set_parameters (process%get_var_list_ptr ()) end associate end if end do end associate 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. <>= procedure :: set_cuts => process_set_cuts <>= module subroutine process_set_cuts (process, ef_cuts) class(process_t), intent(inout) :: process class(expr_factory_t), intent(in) :: ef_cuts end subroutine process_set_cuts <>= module 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. <>= 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 <>= module subroutine process_set_scale (process, ef_scale) class(process_t), intent(inout) :: process class(expr_factory_t), intent(in) :: ef_scale end subroutine process_set_scale module subroutine process_set_weight (process, ef_weight) class(process_t), intent(inout) :: process class(expr_factory_t), intent(in) :: ef_weight end subroutine process_set_weight module subroutine process_set_fac_scale (process, ef_fac_scale) class(process_t), intent(inout) :: process class(expr_factory_t), intent(in) :: ef_fac_scale end subroutine process_set_fac_scale module subroutine process_set_ren_scale (process, ef_ren_scale) class(process_t), intent(inout) :: process class(expr_factory_t), intent(in) :: ef_ren_scale end subroutine process_set_ren_scale <>= module 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 module 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 module 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 module 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. <>= procedure :: compute_md5sum => process_compute_md5sum <>= module subroutine process_compute_md5sum (process) class(process_t), intent(inout) :: process end subroutine process_compute_md5sum <>= module 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 @ <>= procedure :: sampler_test => process_sampler_test <>= module 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 end subroutine process_sampler_test <>= module 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. <>= procedure :: final_integration => process_final_integration procedure :: integrate_dummy => process_integrate_dummy <>= module subroutine process_final_integration (process, i_mci) class(process_t), intent(inout) :: process integer, intent(in) :: i_mci end subroutine process_final_integration module subroutine process_integrate_dummy (process) class(process_t), intent(inout) :: process end subroutine process_integrate_dummy <>= module 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 module 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 @ <>= procedure :: integrate => process_integrate <>= module 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 end subroutine process_integrate <>= module 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 @ <>= procedure :: generate_weighted_event => process_generate_weighted_event <>= module 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 end subroutine process_generate_weighted_event <>= module 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 <>= procedure :: generate_unweighted_event => process_generate_unweighted_event <>= module 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 end subroutine process_generate_unweighted_event <>= module 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 and not if a combined integration of all components together has been performed. <>= procedure :: display_summed_results => process_display_summed_results <>= module subroutine process_display_summed_results (process, pacify) class(process_t), intent(inout) :: process logical, intent(in) :: pacify end subroutine process_display_summed_results <>= module 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 (.not. pcm%settings%combined_integration .and. & 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. <>= procedure :: display_integration_history => & process_display_integration_history <>= module 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 end subroutine process_display_integration_history <>= module 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. <>= procedure :: write_logfile => process_write_logfile <>= module 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 end subroutine process_write_logfile <>= module 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.) 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) call process%env%write (u, show_var_list=.true., & show_model=.false., show_lib=.false., show_os_data=.false.) 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). <>= procedure :: write_state_summary => process_write_state_summary <>= module subroutine process_write_state_summary (process, unit) class(process_t), intent(in) :: process integer, intent(in), optional :: unit end subroutine process_write_state_summary <>= module 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. <>= procedure :: prepare_simulation => process_prepare_simulation <>= module subroutine process_prepare_simulation (process, i_mci) class(process_t), intent(inout) :: process integer, intent(in) :: i_mci end subroutine process_prepare_simulation <>= module 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. <>= 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 <>= module function process_has_integral_tot (process) result (flag) logical :: flag class(process_t), intent(in) :: process end function process_has_integral_tot module function process_has_integral_mci (process, i_mci) result (flag) logical :: flag class(process_t), intent(in) :: process integer, intent(in) :: i_mci end function process_has_integral_mci <>= module 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 module 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]]. <>= 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 <>= module function process_get_integral_mci (process, i_mci) result (integral) real(default) :: integral class(process_t), intent(in) :: process integer, intent(in) :: i_mci end function process_get_integral_mci module function process_get_error_mci (process, i_mci) result (error) real(default) :: error class(process_t), intent(in) :: process integer, intent(in) :: i_mci end function process_get_error_mci module function process_get_efficiency_mci & (process, i_mci) result (efficiency) real(default) :: efficiency class(process_t), intent(in) :: process integer, intent(in) :: i_mci end function process_get_efficiency_mci module function process_get_integral_tot (process) result (integral) real(default) :: integral class(process_t), intent(in) :: process end function process_get_integral_tot module function process_get_error_tot (process) result (error) real(default) :: variance class(process_t), intent(in) :: process real(default) :: error end function process_get_error_tot module function process_get_efficiency_tot (process) result (efficiency) real(default) :: efficiency class(process_t), intent(in) :: process end function process_get_efficiency_tot <>= module 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 module 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 module 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 module 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 module 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 module 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 NLO and the LO result $\iota = I_{NLO} / I_{LO}$. 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*} <>= procedure :: get_correction => process_get_correction procedure :: get_correction_error => process_get_correction_error <>= module function process_get_correction (process) result (ratio) real(default) :: ratio class(process_t), intent(in) :: process end function process_get_correction module function process_get_correction_error (process) result (error) real(default) :: error class(process_t), intent(in) :: process end function process_get_correction_error <>= module function process_get_correction (process) result (ratio) real(default) :: ratio class(process_t), intent(in) :: process integer :: i_mci, i_component real(default) :: int_born, int_nlo int_nlo = zero int_born = process%mci_entry(1)%get_integral () i_mci = 2 do i_component = 2, size (process%component) if (process%component_can_be_integrated (i_component)) then int_nlo = int_nlo + process%mci_entry(i_mci)%get_integral () i_mci = i_mci + 1 end if end do ratio = int_nlo / int_born * 100 end function process_get_correction module 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, i_component sum_int_nlo = zero; err2 = zero int_born = process%mci_entry(1)%get_integral () err_born = process%mci_entry(1)%get_error () i_mci = 2 do i_component = 2, size (process%component) if (process%component_can_be_integrated (i_component)) then sum_int_nlo = sum_int_nlo + process%mci_entry(i_mci)%get_integral () err2 = err2 + process%mci_entry(i_mci)%get_error()**2 i_mci = i_mci + 1 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 @ This routine asks [[beam_config]] for the frame. <>= procedure :: lab_is_cm => process_lab_is_cm <>= pure module function process_lab_is_cm (process) result (lab_is_cm) logical :: lab_is_cm class(process_t), intent(in) :: process end function process_lab_is_cm <>= pure module function process_lab_is_cm (process) result (lab_is_cm) logical :: lab_is_cm class(process_t), intent(in) :: process lab_is_cm = process%beam_config%lab_is_cm end function process_lab_is_cm @ %def process_lab_is_cm @ <>= procedure :: get_component_ptr => process_get_component_ptr <>= module 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 end function process_get_component_ptr <>= module 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 @ <>= procedure :: get_qcd => process_get_qcd <>= module function process_get_qcd (process) result (qcd) type(qcd_t) :: qcd class(process_t), intent(in) :: process end function process_get_qcd <>= module function process_get_qcd (process) result (qcd) type(qcd_t) :: qcd class(process_t), intent(in) :: process qcd = process%config%get_qcd () end function process_get_qcd @ %def process_get_qcd @ <>= generic :: get_component_type => get_component_type_single procedure :: get_component_type_single => process_get_component_type_single <>= elemental module 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 end function process_get_component_type_single <>= elemental module 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 @ <>= generic :: get_component_type => get_component_type_all procedure :: get_component_type_all => process_get_component_type_all <>= module function process_get_component_type_all & (process) result (comp_type) integer, dimension(:), allocatable :: comp_type class(process_t), intent(in) :: process end function process_get_component_type_all <>= module 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 @ <>= procedure :: get_component_i_terms => process_get_component_i_terms <>= module 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 end function process_get_component_i_terms <>= module 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 @ <>= procedure :: get_n_allowed_born => process_get_n_allowed_born <>= module 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 end function process_get_n_allowed_born <>= module 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. <>= procedure :: get_pcm_ptr => process_get_pcm_ptr <>= module function process_get_pcm_ptr (process) result (pcm) class(pcm_t), pointer :: pcm class(process_t), intent(in), target :: process end function process_get_pcm_ptr <>= module 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 <>= 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 <>= module 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 end function process_component_can_be_integrated_single <>= module 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 @ <>= procedure :: component_can_be_integrated_all => & process_component_can_be_integrated_all <>= module function process_component_can_be_integrated_all & (process) result (val) logical, dimension(:), allocatable :: val class(process_t), intent(in) :: process end function process_component_can_be_integrated_all <>= module 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 @ <>= procedure :: reset_selected_cores => process_reset_selected_cores <>= pure module subroutine process_reset_selected_cores (process) class(process_t), intent(inout) :: process end subroutine process_reset_selected_cores <>= pure module subroutine process_reset_selected_cores (process) class(process_t), intent(inout) :: process process%pcm%component_selected = .false. end subroutine process_reset_selected_cores @ %def process_reset_selected_cores @ <>= procedure :: select_components => process_select_components <>= pure module subroutine process_select_components (process, indices) class(process_t), intent(inout) :: process integer, dimension(:), intent(in) :: indices end subroutine process_select_components <>= pure module subroutine process_select_components (process, indices) class(process_t), intent(inout) :: process integer, dimension(:), intent(in) :: indices associate (pcm => process%pcm) pcm%component_selected(indices) = .true. end associate end subroutine process_select_components @ %def process_select_components @ <>= procedure :: component_is_selected => process_component_is_selected <>= pure module function process_component_is_selected & (process, index) result (val) logical :: val class(process_t), intent(in) :: process integer, intent(in) :: index end function process_component_is_selected <>= pure module function process_component_is_selected & (process, index) result (val) logical :: val class(process_t), intent(in) :: process integer, intent(in) :: index associate (pcm => process%pcm) val = pcm%component_selected(index) end associate end function process_component_is_selected @ %def process_component_is_selected @ <>= procedure :: get_coupling_powers => process_get_coupling_powers <>= pure module subroutine process_get_coupling_powers & (process, alpha_power, alphas_power) class(process_t), intent(in) :: process integer, intent(out) :: alpha_power, alphas_power end subroutine process_get_coupling_powers <>= pure module 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 @ <>= procedure :: get_real_component => process_get_real_component <>= module function process_get_real_component (process) result (i_real) integer :: i_real class(process_t), intent(in) :: process end function process_get_real_component <>= module 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 @ <>= procedure :: extract_active_component_mci => & process_extract_active_component_mci <>= module function process_extract_active_component_mci & (process) result (i_active) integer :: i_active class(process_t), intent(in) :: process end function process_extract_active_component_mci <>= module 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 @ <>= procedure :: uses_real_partition => process_uses_real_partition <>= module function process_uses_real_partition (process) result (val) logical :: val class(process_t), intent(in) :: process end function process_uses_real_partition <>= module 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. <>= procedure :: get_md5sum_prc => process_get_md5sum_prc <>= module function process_get_md5sum_prc & (process, i_component) result (md5sum) character(32) :: md5sum class(process_t), intent(in) :: process integer, intent(in) :: i_component end function process_get_md5sum_prc <>= module 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. <>= procedure :: get_md5sum_mci => process_get_md5sum_mci <>= module function process_get_md5sum_mci (process, i_mci) result (md5sum) character(32) :: md5sum class(process_t), intent(in) :: process integer, intent(in) :: i_mci end function process_get_md5sum_mci <>= module 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. <>= procedure :: get_md5sum_cfg => process_get_md5sum_cfg <>= module function process_get_md5sum_cfg (process) result (md5sum) character(32) :: md5sum class(process_t), intent(in) :: process end function process_get_md5sum_cfg <>= module 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 @ <>= procedure :: get_n_cores => process_get_n_cores <>= module function process_get_n_cores (process) result (n) integer :: n class(process_t), intent(in) :: process end function process_get_n_cores <>= module function process_get_n_cores (process) result (n) integer :: n class(process_t), intent(in) :: process n = process%pcm%n_cores end function process_get_n_cores @ %def process_get_n_cores @ <>= procedure :: get_base_i_term => process_get_base_i_term <>= module 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 end function process_get_base_i_term <>= module 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 @ <>= procedure :: get_core_term => process_get_core_term <>= module 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 end function process_get_core_term <>= module 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%core_entry(i_core)%get_core_ptr () end function process_get_core_term @ %def process_get_core_term @ <>= procedure :: get_core_ptr => process_get_core_ptr <>= module function process_get_core_ptr (process, i_core) result (core) class(prc_core_t), pointer :: core class(process_t), intent(in), target :: process integer, intent(in) :: i_core end function process_get_core_ptr <>= module function process_get_core_ptr (process, i_core) result (core) class(prc_core_t), pointer :: core class(process_t), intent(in), target :: process integer, intent(in) :: i_core if (allocated (process%core_entry)) then core => process%core_entry(i_core)%get_core_ptr () else core => null () end if end function process_get_core_ptr @ %def process_get_core_ptr @ <>= procedure :: get_term_ptr => process_get_term_ptr <>= module 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 end function process_get_term_ptr <>= module 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 @ <>= procedure :: get_i_term => process_get_i_term <>= module 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 end function process_get_i_term <>= module 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 @ <>= procedure :: get_i_core => process_get_i_core <>= module function process_get_i_core (process, i_term) result (i_core) class(process_t), intent(in) :: process integer, intent(in) :: i_term integer :: i_core end function process_get_i_core <>= module function process_get_i_core (process, i_term) result (i_core) class(process_t), intent(in) :: process integer, intent(in) :: i_term integer :: i_core i_core = process%term(i_term)%i_core end function process_get_i_core @ %def process_get_i_core @ <>= procedure :: set_i_mci_work => process_set_i_mci_work <>= module subroutine process_set_i_mci_work (process, i_mci) class(process_t), intent(inout) :: process integer, intent(in) :: i_mci end subroutine process_set_i_mci_work <>= module 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 @ <>= procedure :: get_i_mci_work => process_get_i_mci_work <>= pure module 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 end function process_get_i_mci_work <>= pure module 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 @ <>= procedure :: get_i_sub => process_get_i_sub <>= elemental module 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 end function process_get_i_sub <>= elemental module 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 @ <>= procedure :: get_i_term_virtual => process_get_i_term_virtual <>= elemental module function process_get_i_term_virtual & (process) result (i_term) integer :: i_term class(process_t), intent(in) :: process end function process_get_i_term_virtual <>= elemental module 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 @ <>= generic :: component_is_active => component_is_active_single procedure :: component_is_active_single => process_component_is_active_single <>= elemental module function process_component_is_active_single & (process, i_comp) result (val) logical :: val class(process_t), intent(in) :: process integer, intent(in) :: i_comp end function process_component_is_active_single <>= elemental module 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 @ <>= generic :: component_is_active => component_is_active_all procedure :: component_is_active_all => process_component_is_active_all <>= pure module function process_component_is_active_all (process) result (val) logical, dimension(:), allocatable :: val class(process_t), intent(in) :: process end function process_component_is_active_all <>= pure module 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. <>= 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 <>= module function process_get_n_pass_default (process) result (n_pass) class(process_t), intent(in) :: process integer :: n_pass end function process_get_n_pass_default module function process_adapt_grids_default (process, pass) result (flag) class(process_t), intent(in) :: process integer, intent(in) :: pass logical :: flag end function process_adapt_grids_default module function process_adapt_weights_default (process, pass) result (flag) class(process_t), intent(in) :: process integer, intent(in) :: pass logical :: flag end function process_adapt_weights_default <>= module 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 module 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 module 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. <>= procedure :: get_n_it_default => process_get_n_it_default procedure :: get_n_calls_default => process_get_n_calls_default <>= module function process_get_n_it_default (process, pass) result (n_it) class(process_t), intent(in) :: process integer, intent(in) :: pass integer :: n_it end function process_get_n_it_default module function process_get_n_calls_default (process, pass) result (n_calls) class(process_t), intent(in) :: process integer, intent(in) :: pass integer :: n_calls end function process_get_n_calls_default <>= module 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 module 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} Manually set the Run ID (unit test only). <>= procedure :: set_run_id => process_set_run_id <>= module subroutine process_set_run_id (process, run_id) class(process_t), intent(inout) :: process type(string_t), intent(in) :: run_id end subroutine process_set_run_id <>= module subroutine process_set_run_id (process, run_id) class(process_t), intent(inout) :: process type(string_t), intent(in) :: run_id process%meta%run_id = run_id end subroutine process_set_run_id @ %def process_set_run_id @ The following methods return basic process data that stay constant after initialization. The process and IDs. <>= 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 <>= module function process_get_id (process) result (id) class(process_t), intent(in) :: process type(string_t) :: id end function process_get_id module function process_get_num_id (process) result (id) class(process_t), intent(in) :: process integer :: id end function process_get_num_id module function process_get_run_id (process) result (id) class(process_t), intent(in) :: process type(string_t) :: id end function process_get_run_id module function process_get_library_name (process) result (id) class(process_t), intent(in) :: process type(string_t) :: id end function process_get_library_name <>= module 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 module 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 module 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 module function process_get_library_name (process) result (id) class(process_t), intent(in) :: process type(string_t) :: id id = process%meta%lib_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. <>= procedure :: get_n_in => process_get_n_in <>= module function process_get_n_in (process) result (n) class(process_t), intent(in) :: process integer :: n end function process_get_n_in <>= module 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. <>= procedure :: get_n_mci => process_get_n_mci <>= module function process_get_n_mci (process) result (n) class(process_t), intent(in) :: process integer :: n end function process_get_n_mci <>= module 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. <>= procedure :: get_n_components => process_get_n_components <>= module function process_get_n_components (process) result (n) class(process_t), intent(in) :: process integer :: n end function process_get_n_components <>= module 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. <>= procedure :: get_n_terms => process_get_n_terms <>= module function process_get_n_terms (process) result (n) class(process_t), intent(in) :: process integer :: n end function process_get_n_terms <>= module 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. <>= procedure :: get_i_component => process_get_i_component <>= module 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 end subroutine process_get_i_component <>= module 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. <>= procedure :: get_component_id => process_get_component_id <>= module 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 end function process_get_component_id <>= module 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. <>= procedure :: get_component_def_ptr => process_get_component_def_ptr <>= module 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 end function process_get_component_def_ptr <>= module 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%config%process_def%get_component_def_ptr (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. <>= procedure :: extract_core => process_extract_core procedure :: restore_core => process_restore_core <>= module 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 end subroutine process_extract_core module 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 end subroutine process_restore_core <>= module 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%core_entry(i_core)%core, to = core) end subroutine process_extract_core module 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%core_entry(i_core)%core) end subroutine process_restore_core @ %def process_extract_core @ %def process_restore_core @ The block of process constants. <>= procedure :: get_constants => process_get_constants <>= module 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 end function process_get_constants <>= module 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%core_entry(i_core)%core%data end function process_get_constants @ %def process_get_constants @ <>= procedure :: get_config => process_get_config <>= module function process_get_config (process) result (config) type(process_config_data_t) :: config class(process_t), intent(in) :: process end function process_get_config <>= module 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 @ Construct an MD5 sum for the constant data, including the NLO type. For the NLO type [[NLO_MISMATCH]], we pretend that this was [[NLO_SUBTRACTION]] instead. TODO wk 2018: should not depend explicitly on NLO data. <>= procedure :: get_md5sum_constants => process_get_md5sum_constants <>= module 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 end function process_get_md5sum_constants <>= module 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%env%fill_process_constants (process%meta%id, i_component, data) unit = data%fill_unit_for_md5sum (.false.) write (unit, '(A)') char(type_string) select case (nlo_type) case (NLO_MISMATCH) write (unit, '(I0)') NLO_SUBTRACTION case default write (unit, '(I0)') nlo_type end select 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. <>= procedure :: get_term_flv_out => process_get_term_flv_out <>= module 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 end subroutine process_get_term_flv_out <>= module 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 int%get_flv_out (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. <>= procedure :: contains_unstable => process_contains_unstable <>= module function process_contains_unstable (process, model) result (flag) class(process_t), intent(in) :: process class(model_data_t), intent(in), target :: model logical :: flag end function process_contains_unstable <>= module 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. <>= procedure :: get_sqrts => process_get_sqrts <>= module function process_get_sqrts (process) result (sqrts) class(process_t), intent(in) :: process real(default) :: sqrts end function process_get_sqrts <>= module 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 lab-frame beam energy/energies.. <>= procedure :: get_energy => process_get_energy <>= module function process_get_energy (process) result (e) class(process_t), intent(in) :: process real(default), dimension(:), allocatable :: e end function process_get_energy <>= module function process_get_energy (process) result (e) class(process_t), intent(in) :: process real(default), dimension(:), allocatable :: e e = process%beam_config%data%get_energy () end function process_get_energy @ %def process_get_energy @ The beam polarization in case of simple degrees. <>= procedure :: get_polarization => process_get_polarization <>= module function process_get_polarization (process) result (pol) class(process_t), intent(in) :: process real(default), dimension(process%beam_config%data%n) :: pol end function process_get_polarization <>= module function process_get_polarization (process) result (pol) class(process_t), intent(in) :: process real(default), dimension(process%beam_config%data%n) :: pol pol = process%beam_config%data%get_polarization () end function process_get_polarization @ %def process_get_polarization @ <>= procedure :: get_meta => process_get_meta <>= module function process_get_meta (process) result (meta) type(process_metadata_t) :: meta class(process_t), intent(in) :: process end function process_get_meta <>= module 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 <>= procedure :: has_matrix_element => process_has_matrix_element <>= module 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 end function process_has_matrix_element <>= module 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. <>= procedure :: get_beam_data_ptr => process_get_beam_data_ptr <>= module function process_get_beam_data_ptr (process) result (beam_data) class(process_t), intent(in), target :: process type(beam_data_t), pointer :: beam_data end function process_get_beam_data_ptr <>= module 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 @ <>= procedure :: get_beam_config => process_get_beam_config <>= module function process_get_beam_config (process) result (beam_config) type(process_beam_config_t) :: beam_config class(process_t), intent(in) :: process end function process_get_beam_config <>= module 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 @ <>= procedure :: get_beam_config_ptr => process_get_beam_config_ptr <>= module 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 end function process_get_beam_config_ptr <>= module 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 @ Get the PDF set currently in use, if any. <>= procedure :: get_pdf_set => process_get_pdf_set <>= module function process_get_pdf_set (process) result (pdf_set) class(process_t), intent(in) :: process integer :: pdf_set end function process_get_pdf_set <>= module 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 @ <>= procedure :: pcm_contains_pdfs => process_pcm_contains_pdfs <>= module function process_pcm_contains_pdfs (process) result (has_pdfs) logical :: has_pdfs class(process_t), intent(in) :: process end function process_pcm_contains_pdfs <>= module 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. <>= procedure :: get_beam_file => process_get_beam_file <>= module function process_get_beam_file (process) result (file) class(process_t), intent(in) :: process type(string_t) :: file end function process_get_beam_file <>= module 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. <>= procedure :: get_var_list_ptr => process_get_var_list_ptr <>= module function process_get_var_list_ptr (process) result (ptr) class(process_t), intent(in), target :: process type(var_list_t), pointer :: ptr end function process_get_var_list_ptr <>= module function process_get_var_list_ptr (process) result (ptr) class(process_t), intent(in), target :: process type(var_list_t), pointer :: ptr ptr => process%env%get_var_list_ptr () end function process_get_var_list_ptr @ %def process_get_var_list_ptr @ Pointer to the common model. <>= procedure :: get_model_ptr => process_get_model_ptr <>= module function process_get_model_ptr (process) result (ptr) class(process_t), intent(in) :: process class(model_data_t), pointer :: ptr end function process_get_model_ptr <>= module 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.) <>= procedure :: make_rng => process_make_rng <>= module subroutine process_make_rng (process, rng) class(process_t), intent(inout) :: process class(rng_t), intent(out), allocatable :: rng end subroutine process_make_rng <>= module subroutine process_make_rng (process, rng) class(process_t), intent(inout) :: process class(rng_t), intent(out), allocatable :: rng if (allocated (process%rng_factory)) then call process%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. <>= procedure :: compute_amplitude => process_compute_amplitude <>= module 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), target :: 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 complex(default) :: amp end function process_compute_amplitude <>= module 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), target :: 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 real(default) :: fscale, rscale real(default), allocatable :: aqcd_forced complex(default) :: amp class(prc_core_t), pointer :: core amp = 0 if (0 < i .and. i <= process%meta%n_components) then if (process%component(i)%active) then associate (core => process%core_entry(i_core)%core) 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 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. <>= procedure :: check_library_sanity => process_check_library_sanity <>= module subroutine process_check_library_sanity (process) class(process_t), intent(in) :: process end subroutine process_check_library_sanity <>= module subroutine process_check_library_sanity (process) class(process_t), intent(in) :: process call process%env%check_lib_sanity (process%meta) end subroutine process_check_library_sanity @ %def process_check_library_sanity @ Reset the association to a process library. <>= procedure :: reset_library_ptr => process_reset_library_ptr <>= module subroutine process_reset_library_ptr (process) class(process_t), intent(inout) :: process end subroutine process_reset_library_ptr <>= module subroutine process_reset_library_ptr (process) class(process_t), intent(inout) :: process call process%env%reset_lib_ptr () end subroutine process_reset_library_ptr @ %def process_reset_library_ptr @ <>= procedure :: set_counter_mci_entry => process_set_counter_mci_entry <>= module 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 end subroutine process_set_counter_mci_entry <>= module 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. <>= procedure :: pacify => process_pacify <>= module subroutine process_pacify (process, efficiency_reset, error_reset) class(process_t), intent(inout) :: process logical, intent(in), optional :: efficiency_reset, error_reset end subroutine process_pacify <>= module 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. <>= procedure :: test_allocate_sf_channels procedure :: test_set_component_sf_channel procedure :: test_get_mci_ptr <>= module subroutine test_allocate_sf_channels (process, n) class(process_t), intent(inout) :: process integer, intent(in) :: n end subroutine test_allocate_sf_channels module subroutine test_set_component_sf_channel (process, c) class(process_t), intent(inout) :: process integer, dimension(:), intent(in) :: c end subroutine test_set_component_sf_channel module subroutine test_get_mci_ptr (process, mci) class(process_t), intent(in), target :: process class(mci_t), intent(out), pointer :: mci end subroutine test_get_mci_ptr <>= module 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 module 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 module 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 @ <>= procedure :: init_mci_work => process_init_mci_work <>= module 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 end subroutine process_init_mci_work <>= module 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 @ Prepare the process core with type [[test_me]], or otherwise the externally provided [[type_string]] version. The toy dispatchers as a procedure argument come handy, knowing that we need to support only the [[test_me]] and [[template]] matrix-element types. Gfortran 7/8/9 bug, has to remain in the main module: <>= procedure :: setup_test_cores => process_setup_test_cores <>= subroutine dispatch_test_me_core (core, core_def, model, & helicity_selection, qcd, use_color_factors, has_beam_pol) use prc_test_core, only: test_t class(prc_core_t), allocatable, intent(inout) :: core class(prc_core_def_t), intent(in) :: core_def class(model_data_t), intent(in), target, optional :: model type(helicity_selection_t), intent(in), optional :: helicity_selection type(qcd_t), intent(in), optional :: qcd logical, intent(in), optional :: use_color_factors logical, intent(in), optional :: has_beam_pol allocate (test_t :: core) end subroutine dispatch_test_me_core subroutine dispatch_template_core (core, core_def, model, & helicity_selection, qcd, use_color_factors, has_beam_pol) use prc_template_me, only: prc_template_me_t class(prc_core_t), allocatable, intent(inout) :: core class(prc_core_def_t), intent(in) :: core_def class(model_data_t), intent(in), target, optional :: model type(helicity_selection_t), intent(in), optional :: helicity_selection type(qcd_t), intent(in), optional :: qcd logical, intent(in), optional :: use_color_factors logical, intent(in), optional :: has_beam_pol allocate (prc_template_me_t :: core) select type (core) type is (prc_template_me_t) call core%set_parameters (model) end select end subroutine dispatch_template_core 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 if (present (type_string)) then select case (char (type_string)) case ("template") call process%setup_cores (dispatch_template_core) case ("test_me") call process%setup_cores (dispatch_test_me_core) case default call msg_bug ("process setup test cores: unsupported type string") end select else call process%setup_cores (dispatch_test_me_core) end if end subroutine process_setup_test_cores @ %def process_setup_test_cores @ <>= procedure :: get_connected_states => process_get_connected_states <>= module 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 end function process_get_connected_states <>= module 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]] TODO wk 2018: This is used only by event initialization, which deals with an incomplete process object. <>= procedure :: init_nlo_settings => process_init_nlo_settings <>= module subroutine process_init_nlo_settings (process, var_list) class(process_t), intent(inout) :: process type(var_list_t), intent(in), target :: var_list end subroutine process_init_nlo_settings <>= module subroutine process_init_nlo_settings (process, var_list) class(process_t), intent(inout) :: process type(var_list_t), intent(in), target :: var_list select type (pcm => process%pcm) type is (pcm_nlo_t) call pcm%init_nlo_settings (var_list) 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 @ <>= generic :: get_nlo_type_component => get_nlo_type_component_single procedure :: get_nlo_type_component_single => & process_get_nlo_type_component_single <>= elemental module 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 end function process_get_nlo_type_component_single <>= elemental module 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 @ <>= generic :: get_nlo_type_component => get_nlo_type_component_all procedure :: get_nlo_type_component_all => process_get_nlo_type_component_all <>= pure module function process_get_nlo_type_component_all & (process) result (val) integer, dimension(:), allocatable :: val class(process_t), intent(in) :: process end function process_get_nlo_type_component_all <>= pure module 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 @ <>= procedure :: is_nlo_calculation => process_is_nlo_calculation <>= module function process_is_nlo_calculation (process) result (nlo) logical :: nlo class(process_t), intent(in) :: process end function process_is_nlo_calculation <>= module 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 @ <>= procedure :: get_negative_sf => process_get_negative_sf <>= module function process_get_negative_sf (process) result (neg_sf) logical :: neg_sf class(process_t), intent(in) :: process end function process_get_negative_sf <>= module function process_get_negative_sf (process) result (neg_sf) logical :: neg_sf class(process_t), intent(in) :: process neg_sf = process%config%process_def%get_negative_sf () end function process_get_negative_sf @ %def process_get_negative_sf @ <>= procedure :: is_combined_nlo_integration & => process_is_combined_nlo_integration <>= module function process_is_combined_nlo_integration & (process) result (combined) logical :: combined class(process_t), intent(in) :: process end function process_is_combined_nlo_integration <>= module 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 @ <>= procedure :: component_is_real_finite => process_component_is_real_finite <>= pure module function process_component_is_real_finite & (process, i_component) result (val) logical :: val class(process_t), intent(in) :: process integer, intent(in) :: i_component end function process_component_is_real_finite <>= pure module 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 <>= procedure :: get_component_nlo_type => process_get_component_nlo_type <>= elemental module 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 end function process_get_component_nlo_type <>= elemental module 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 @ Return a pointer to the core that belongs to a component. <>= procedure :: get_component_core_ptr => process_get_component_core_ptr <>= module function process_get_component_core_ptr & (process, i_component) result (core) class(process_t), intent(in), target :: process integer, intent(in) :: i_component class(prc_core_t), pointer :: core end function process_get_component_core_ptr <>= module function process_get_component_core_ptr & (process, i_component) result (core) class(process_t), intent(in), target :: process integer, intent(in) :: i_component class(prc_core_t), pointer :: core integer :: i_core i_core = process%pcm%get_i_core(i_component) core => process%core_entry(i_core)%core end function process_get_component_core_ptr @ %def process_get_component_core_ptr @ <>= procedure :: get_component_associated_born & => process_get_component_associated_born <>= module 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 end function process_get_component_associated_born <>= module 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 @ <>= procedure :: get_first_real_component => process_get_first_real_component <>= module function process_get_first_real_component (process) result (i_real) integer :: i_real class(process_t), intent(in) :: process end function process_get_first_real_component <>= module 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 @ <>= procedure :: get_first_real_term => process_get_first_real_term <>= module function process_get_first_real_term (process) result (i_real) integer :: i_real class(process_t), intent(in) :: process integer :: i_component, i_term end function process_get_first_real_term <>= module 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 @ <>= procedure :: get_associated_real_fin => process_get_associated_real_fin <>= elemental module 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 end function process_get_associated_real_fin <>= elemental module 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 @ <>= procedure :: select_i_term => process_select_i_term <>= pure module 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 end function process_select_i_term <>= pure module 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 @ Would be better to do this at the level of the writer of the core but one has to bring NLO information there. <>= procedure :: prepare_any_external_code & => process_prepare_any_external_code <>= module subroutine process_prepare_any_external_code (process) class(process_t), intent(inout), target :: process end subroutine process_prepare_any_external_code <>= module subroutine process_prepare_any_external_code (process) class(process_t), intent(inout), target :: process integer :: i if (debug_on) call msg_debug2 (D_PROCESS_INTEGRATION, & "process_prepare_external_code") associate (pcm => process%pcm) do i = 1, pcm%n_cores call pcm%prepare_any_external_code ( & process%core_entry(i), i, & process%get_library_name (), & process%config%model, & process%env%get_var_list_ptr ()) end do end associate end subroutine process_prepare_any_external_code @ %def process_prepare_any_external_code @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{Process config} <<[[process_config.f90]]>>= <> module process_config <> <> use os_interface use sf_base use sf_mappings use mappings, only: mapping_defaults_t use phs_forests, only: phs_parameters_t use sm_qcd use integration_results use flavors use interactions use model_data use models use process_libraries use process_constants use prc_core use beams use mci_base use beam_structures use dispatch_beams, only: dispatch_qcd use phs_base use expr_base use variables <> <> <> <> interface <> end interface contains <> end module process_config @ %def process_config @ <<[[process_config_sub.f90]]>>= <> submodule (process_config) process_config_s use format_utils, only: write_separator use io_units use diagnostics use md5 use physics_defs use helicities use colors use quantum_numbers use state_matrices use prc_external use prc_openloops, only: prc_openloops_t use prc_threshold, only: prc_threshold_t use blha_olp_interfaces, only: prc_blha_t implicit none contains <> end submodule process_config_s @ %def process_config_s @ Identifiers for the NLO setup. <>= 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{Output selection flags} We declare a number of identifiers for write methods, so they only displays selected parts. The identifiers can be supplied to the [[vlist]] array argument of the standard F2008 derived-type writer call. <>= integer, parameter, public :: F_PACIFY = 1 integer, parameter, public :: F_SHOW_VAR_LIST = 11 integer, parameter, public :: F_SHOW_EXPRESSIONS = 12 integer, parameter, public :: F_SHOW_LIB = 13 integer, parameter, public :: F_SHOW_MODEL = 14 integer, parameter, public :: F_SHOW_QCD = 15 integer, parameter, public :: F_SHOW_OS_DATA = 16 integer, parameter, public :: F_SHOW_RNG = 17 integer, parameter, public :: F_SHOW_BEAMS = 18 @ %def SHOW_VAR_LIST @ %def SHOW_EXPRESSIONS @ This is a simple function that returns true if a flag value is present in [[v_list]], but not its negative. If neither is present, it returns [[default]]. <>= public :: flagged <>= module function flagged (v_list, id, def) result (flag) logical :: flag integer, dimension(:), intent(in) :: v_list integer, intent(in) :: id logical, intent(in), optional :: def end function flagged <>= module function flagged (v_list, id, def) result (flag) logical :: flag integer, dimension(:), intent(in) :: v_list integer, intent(in) :: id logical, intent(in), optional :: def logical :: default_result default_result = .false.; if (present (def)) default_result = def if (default_result) then flag = all (v_list /= -id) else flag = all (v_list /= -id) .and. any (v_list == id) end if end function flagged @ %def flagged @ Related: if flag is set (unset), append [[value]] (its negative) to the [[v_list]], respectively. [[v_list]] must be allocated. <>= public :: set_flag <>= module subroutine set_flag (v_list, value, flag) integer, dimension(:), intent(inout), allocatable :: v_list integer, intent(in) :: value logical, intent(in), optional :: flag end subroutine set_flag <>= module subroutine set_flag (v_list, value, flag) integer, dimension(:), intent(inout), allocatable :: v_list integer, intent(in) :: value logical, intent(in), optional :: flag if (present (flag)) then if (flag) then v_list = [v_list, value] else v_list = [v_list, -value] end if end if end subroutine set_flag @ %def set_flag @ \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. 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. <>= public :: process_config_data_t <>= type :: process_config_data_t class(process_def_t), pointer :: process_def => null () integer :: n_in = 0 integer :: n_components = 0 integer :: n_terms = 0 integer :: n_mci = 0 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 <> end type process_config_data_t @ %def process_config_data_t @ Here, we may compress the expressions for cuts etc. <>= procedure :: write => process_config_data_write <>= module subroutine process_config_data_write & (config, u, counters, model, expressions) class(process_config_data_t), intent(in) :: config integer, intent(in) :: u logical, intent(in) :: counters logical, intent(in) :: model logical, intent(in) :: expressions end subroutine process_config_data_write <>= module subroutine process_config_data_write & (config, u, counters, model, expressions) class(process_config_data_t), intent(in) :: config integer, intent(in) :: u logical, intent(in) :: counters 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 (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.) 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 pointer references the model data within the [[env]] record. That should be an instance of the global model. We initialize the QCD object, unless the environment information is unavailable (unit tests). The RNG factory object is imported by moving the allocation. Gfortran 7/8/9 bug: has to remain in the main module: <>= procedure :: init => process_config_data_init <>= subroutine process_config_data_init (config, meta, env) class(process_config_data_t), intent(out) :: config type(process_metadata_t), intent(in) :: meta type(process_environment_t), intent(in) :: env config%process_def => env%lib%get_process_def_ptr (meta%id) config%n_in = config%process_def%get_n_in () config%n_components = size (meta%component_id) config%model => env%get_model_ptr () config%model_name = config%model%get_name () if (env%got_var_list ()) then call dispatch_qcd & (config%qcd, env%get_var_list_ptr (), env%get_os_data ()) end if end subroutine process_config_data_init @ %def process_config_data_init @ Return a copy of the QCD data block. <>= procedure :: get_qcd => process_config_data_get_qcd <>= module function process_config_data_get_qcd (config) result (qcd) class(process_config_data_t), intent(in) :: config type(qcd_t) :: qcd end function process_config_data_get_qcd <>= module function process_config_data_get_qcd (config) result (qcd) class(process_config_data_t), intent(in) :: config type(qcd_t) :: qcd qcd = config%qcd end function process_config_data_get_qcd @ %def process_config_data_get_qcd @ 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. <>= procedure :: compute_md5sum => process_config_data_compute_md5sum <>= module subroutine process_config_data_compute_md5sum (config) class(process_config_data_t), intent(inout) :: config end subroutine process_config_data_compute_md5sum <>= module 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., & 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 @ <>= procedure :: get_md5sum => process_config_data_get_md5sum <>= pure module function process_config_data_get_md5sum (config) result (md5) character(32) :: md5 class(process_config_data_t), intent(in) :: config end function process_config_data_get_md5sum <>= pure module 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{Environment} This record stores a snapshot of the process environment at the point where the process object is created. Model and variable list are implemented as pointer, so they always have the [[target]] attribute. For unit-testing purposes, setting the var list is optional. If not set, the pointer is null. <>= public :: process_environment_t <>= type :: process_environment_t private type(model_t), pointer :: model => null () type(var_list_t), pointer :: var_list => null () logical :: var_list_is_set = .false. type(process_library_t), pointer :: lib => null () type(beam_structure_t) :: beam_structure type(os_data_t) :: os_data contains <> end type process_environment_t @ %def process_environment_t @ Model and local var list are snapshots and need a finalizer. <>= procedure :: final => process_environment_final <>= module subroutine process_environment_final (env) class(process_environment_t), intent(inout) :: env end subroutine process_environment_final <>= module subroutine process_environment_final (env) class(process_environment_t), intent(inout) :: env if (associated (env%model)) then call env%model%final () deallocate (env%model) end if if (associated (env%var_list)) then call env%var_list%final (follow_link=.true.) deallocate (env%var_list) end if end subroutine process_environment_final @ %def process_environment_final @ Output, DTIO compatible. <>= procedure :: write => process_environment_write procedure :: write_formatted => process_environment_write_formatted ! generic :: write (formatted) => write_formatted <>= module subroutine process_environment_write (env, unit, & show_var_list, show_model, show_lib, show_beams, show_os_data) class(process_environment_t), intent(in) :: env integer, intent(in), optional :: unit logical, intent(in), optional :: show_var_list logical, intent(in), optional :: show_model logical, intent(in), optional :: show_lib logical, intent(in), optional :: show_beams logical, intent(in), optional :: show_os_data end subroutine process_environment_write <>= module subroutine process_environment_write (env, unit, & show_var_list, show_model, show_lib, show_beams, show_os_data) class(process_environment_t), intent(in) :: env integer, intent(in), optional :: unit logical, intent(in), optional :: show_var_list logical, intent(in), optional :: show_model logical, intent(in), optional :: show_lib logical, intent(in), optional :: show_beams logical, intent(in), optional :: show_os_data integer :: u, iostat integer, dimension(:), allocatable :: v_list character(0) :: iomsg u = given_output_unit (unit) allocate (v_list (0)) call set_flag (v_list, F_SHOW_VAR_LIST, show_var_list) call set_flag (v_list, F_SHOW_MODEL, show_model) call set_flag (v_list, F_SHOW_LIB, show_lib) call set_flag (v_list, F_SHOW_BEAMS, show_beams) call set_flag (v_list, F_SHOW_OS_DATA, show_os_data) call env%write_formatted (u, "LISTDIRECTED", v_list, iostat, iomsg) end subroutine process_environment_write @ %def process_environment_write @ DTIO standard write. <>= module subroutine process_environment_write_formatted & (dtv, unit, iotype, v_list, iostat, iomsg) class(process_environment_t), intent(in) :: dtv integer, intent(in) :: unit character(*), intent(in) :: iotype integer, dimension(:), intent(in) :: v_list integer, intent(out) :: iostat character(*), intent(inout) :: iomsg end subroutine process_environment_write_formatted <>= module subroutine process_environment_write_formatted & (dtv, unit, iotype, v_list, iostat, iomsg) class(process_environment_t), intent(in) :: dtv integer, intent(in) :: unit character(*), intent(in) :: iotype integer, dimension(:), intent(in) :: v_list integer, intent(out) :: iostat character(*), intent(inout) :: iomsg associate (env => dtv) if (flagged (v_list, F_SHOW_VAR_LIST, .true.)) then write (unit, "(1x,A)") "Variable list:" if (associated (env%var_list)) then call write_separator (unit) call env%var_list%write (unit) else write (unit, "(3x,A)") "[not allocated]" end if call write_separator (unit) end if if (flagged (v_list, F_SHOW_MODEL, .true.)) then write (unit, "(1x,A)") "Model:" if (associated (env%model)) then call write_separator (unit) call env%model%write (unit) else write (unit, "(3x,A)") "[not allocated]" end if call write_separator (unit) end if if (flagged (v_list, F_SHOW_LIB, .true.)) then write (unit, "(1x,A)") "Process library:" if (associated (env%lib)) then call write_separator (unit) call env%lib%write (unit) else write (unit, "(3x,A)") "[not allocated]" end if end if if (flagged (v_list, F_SHOW_BEAMS, .true.)) then call write_separator (unit) call env%beam_structure%write (unit) end if if (flagged (v_list, F_SHOW_OS_DATA, .true.)) then write (unit, "(1x,A)") "Operating-system data:" call write_separator (unit) call env%os_data%write (unit) end if end associate iostat = 0 end subroutine process_environment_write_formatted @ %def process_environment_write_formatted @ Initialize: Make a snapshot of the provided model. Make a link to the current process library. Also make a snapshot of the variable list, if provided. If none is provided, there is an empty variable list nevertheless, so a pointer lookup does not return null. If no beam structure is provided, the beam-structure member is empty and will yield a number of zero beams when queried. <>= procedure :: init => process_environment_init <>= module subroutine process_environment_init & (env, model, lib, os_data, var_list, beam_structure) class(process_environment_t), intent(out) :: env type(model_t), intent(in), target :: model type(process_library_t), intent(in), target :: lib type(os_data_t), intent(in) :: os_data type(var_list_t), intent(in), target, optional :: var_list type(beam_structure_t), intent(in), optional :: beam_structure end subroutine process_environment_init <>= module subroutine process_environment_init & (env, model, lib, os_data, var_list, beam_structure) class(process_environment_t), intent(out) :: env type(model_t), intent(in), target :: model type(process_library_t), intent(in), target :: lib type(os_data_t), intent(in) :: os_data type(var_list_t), intent(in), target, optional :: var_list type(beam_structure_t), intent(in), optional :: beam_structure allocate (env%model) call env%model%init_instance (model) env%lib => lib env%os_data = os_data allocate (env%var_list) if (present (var_list)) then call env%var_list%init_snapshot (var_list, follow_link=.true.) env%var_list_is_set = .true. end if if (present (beam_structure)) then env%beam_structure = beam_structure end if end subroutine process_environment_init @ %def process_environment_init @ Indicate whether a variable list has been provided upon initialization. <>= procedure :: got_var_list => process_environment_got_var_list <>= module function process_environment_got_var_list (env) result (flag) class(process_environment_t), intent(in) :: env logical :: flag end function process_environment_got_var_list <>= module function process_environment_got_var_list (env) result (flag) class(process_environment_t), intent(in) :: env logical :: flag flag = env%var_list_is_set end function process_environment_got_var_list @ %def process_environment_got_var_list @ Return a pointer to the variable list. <>= procedure :: get_var_list_ptr => process_environment_get_var_list_ptr <>= module function process_environment_get_var_list_ptr (env) result (var_list) class(process_environment_t), intent(in) :: env type(var_list_t), pointer :: var_list end function process_environment_get_var_list_ptr <>= module function process_environment_get_var_list_ptr (env) result (var_list) class(process_environment_t), intent(in) :: env type(var_list_t), pointer :: var_list var_list => env%var_list end function process_environment_get_var_list_ptr @ %def process_environment_get_var_list_ptr @ Return a pointer to the model, if it exists. <>= procedure :: get_model_ptr => process_environment_get_model_ptr <>= module function process_environment_get_model_ptr (env) result (model) class(process_environment_t), intent(in) :: env type(model_t), pointer :: model end function process_environment_get_model_ptr <>= module function process_environment_get_model_ptr (env) result (model) class(process_environment_t), intent(in) :: env type(model_t), pointer :: model model => env%model end function process_environment_get_model_ptr @ %def process_environment_get_model_ptr @ Return the process library pointer. <>= procedure :: get_lib_ptr => process_environment_get_lib_ptr <>= module function process_environment_get_lib_ptr (env) result (lib) class(process_environment_t), intent(inout) :: env type(process_library_t), pointer :: lib end function process_environment_get_lib_ptr <>= module function process_environment_get_lib_ptr (env) result (lib) class(process_environment_t), intent(inout) :: env type(process_library_t), pointer :: lib lib => env%lib end function process_environment_get_lib_ptr @ %def process_environment_get_lib_ptr @ Clear the process library pointer, in case the library is deleted. <>= procedure :: reset_lib_ptr => process_environment_reset_lib_ptr <>= module subroutine process_environment_reset_lib_ptr (env) class(process_environment_t), intent(inout) :: env end subroutine process_environment_reset_lib_ptr <>= module subroutine process_environment_reset_lib_ptr (env) class(process_environment_t), intent(inout) :: env env%lib => null () end subroutine process_environment_reset_lib_ptr @ %def process_environment_reset_lib_ptr @ Check whether the process library has changed, in case the library is recompiled, etc. <>= procedure :: check_lib_sanity => process_environment_check_lib_sanity <>= module subroutine process_environment_check_lib_sanity (env, meta) class(process_environment_t), intent(in) :: env type(process_metadata_t), intent(in) :: meta end subroutine process_environment_check_lib_sanity <>= module subroutine process_environment_check_lib_sanity (env, meta) class(process_environment_t), intent(in) :: env type(process_metadata_t), intent(in) :: meta if (associated (env%lib)) then if (env%lib%get_update_counter () /= meta%lib_update_counter) then call msg_fatal ("Process '" // char (meta%id) & // "': library has been recompiled after integration") end if end if end subroutine process_environment_check_lib_sanity @ %def process_environment_check_lib_sanity @ Fill the [[data]] block using the appropriate process-library access entry. <>= procedure :: fill_process_constants => & process_environment_fill_process_constants <>= module subroutine process_environment_fill_process_constants & (env, id, i_component, data) class(process_environment_t), intent(in) :: env type(string_t), intent(in) :: id integer, intent(in) :: i_component type(process_constants_t), intent(out) :: data end subroutine process_environment_fill_process_constants <>= module subroutine process_environment_fill_process_constants & (env, id, i_component, data) class(process_environment_t), intent(in) :: env type(string_t), intent(in) :: id integer, intent(in) :: i_component type(process_constants_t), intent(out) :: data call env%lib%fill_constants (id, i_component, data) end subroutine process_environment_fill_process_constants @ %def process_environment_fill_process_constants @ Return the entire beam structure. <>= procedure :: get_beam_structure => process_environment_get_beam_structure <>= module function process_environment_get_beam_structure & (env) result (beam_structure) class(process_environment_t), intent(in) :: env type(beam_structure_t) :: beam_structure end function process_environment_get_beam_structure <>= module function process_environment_get_beam_structure & (env) result (beam_structure) class(process_environment_t), intent(in) :: env type(beam_structure_t) :: beam_structure beam_structure = env%beam_structure end function process_environment_get_beam_structure @ %def process_environment_get_beam_structure @ Check the beam structure for PDFs. <>= procedure :: has_pdfs => process_environment_has_pdfs <>= module function process_environment_has_pdfs (env) result (flag) class(process_environment_t), intent(in) :: env logical :: flag end function process_environment_has_pdfs <>= module function process_environment_has_pdfs (env) result (flag) class(process_environment_t), intent(in) :: env logical :: flag flag = env%beam_structure%has_pdf () end function process_environment_has_pdfs @ %def process_environment_has_pdfs @ Check the beam structure for polarized beams. <>= procedure :: has_polarized_beams => process_environment_has_polarized_beams <>= module function process_environment_has_polarized_beams (env) result (flag) class(process_environment_t), intent(in) :: env logical :: flag end function process_environment_has_polarized_beams <>= module function process_environment_has_polarized_beams (env) result (flag) class(process_environment_t), intent(in) :: env logical :: flag flag = env%beam_structure%has_polarized_beams () end function process_environment_has_polarized_beams @ %def process_environment_has_polarized_beams @ Return a copy of the OS data block. <>= procedure :: get_os_data => process_environment_get_os_data <>= module function process_environment_get_os_data (env) result (os_data) class(process_environment_t), intent(in) :: env type(os_data_t) :: os_data end function process_environment_get_os_data <>= module function process_environment_get_os_data (env) result (os_data) class(process_environment_t), intent(in) :: env type(os_data_t) :: os_data os_data = env%os_data end function process_environment_get_os_data @ %def process_environment_get_os_data @ \subsection{Metadata} This information describes the process. 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 [[lib_name]] identifies 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. <>= public :: process_metadata_t <>= type :: process_metadata_t integer :: type = PRC_UNKNOWN type(string_t) :: id integer :: num_id = 0 type(string_t) :: run_id type(string_t), allocatable :: lib_name 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 <> end type process_metadata_t @ %def process_metadata_t @ Output: ID and run ID. We write the variable list only upon request. <>= procedure :: write => process_metadata_write <>= module subroutine process_metadata_write (meta, u, screen) class(process_metadata_t), intent(in) :: meta integer, intent(in) :: u logical, intent(in) :: screen end subroutine process_metadata_write <>= module subroutine process_metadata_write (meta, u, screen) class(process_metadata_t), intent(in) :: meta integer, intent(in) :: u logical, intent(in) :: 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 (allocated (meta%lib_name)) then if (screen) then write (msg_buffer, "(2x,A,A,A)") "Library name = '", & char (meta%lib_name), "'" call msg_message () else write (u, "(3x,A,A,A)") "Library name = '", & char (meta%lib_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 end subroutine process_metadata_write @ %def process_metadata_write @ Short output: list components. <>= procedure :: show => process_metadata_show <>= module 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 end subroutine process_metadata_show <>= module 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. Find process ID and run ID. Also find the process ID in the process library and retrieve some metadata from there. <>= procedure :: init => process_metadata_init <>= module subroutine process_metadata_init (meta, id, lib, var_list) class(process_metadata_t), intent(out) :: meta type(string_t), intent(in) :: id type(process_library_t), intent(in), target :: lib type(var_list_t), intent(in) :: var_list end subroutine process_metadata_init <>= module subroutine process_metadata_init (meta, id, lib, var_list) class(process_metadata_t), intent(out) :: meta type(string_t), intent(in) :: id type(process_library_t), intent(in), target :: lib type(var_list_t), intent(in) :: var_list 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 = var_list%get_sval (var_str ("$run_id")) allocate (meta%lib_name) meta%lib_name = lib%get_name () meta%lib_update_counter = lib%get_update_counter () if (lib%contains (id)) then 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.) else call msg_fatal ("Process library does not contain process '" & // char (id) // "'") end if if (.not. lib%is_active ()) then call msg_bug ("Process init: inactive library not handled yet") end if end subroutine process_metadata_init @ %def process_metadata_init @ Mark a component as inactive. <>= procedure :: deactivate_component => process_metadata_deactivate_component <>= module subroutine process_metadata_deactivate_component (meta, i) class(process_metadata_t), intent(inout) :: meta integer, intent(in) :: i end subroutine process_metadata_deactivate_component <>= module 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{Phase-space configuration} A process can have a number of independent phase-space configuration entries, depending on the process definition and evaluation algorithm. Each entry holds various configuration-parameter data and the actual [[phs_config_t]] record, which can vary in concrete type. <>= public :: process_phs_config_t <>= type :: process_phs_config_t type(phs_parameters_t) :: phs_par type(mapping_defaults_t) :: mapping_defs class(phs_config_t), allocatable :: phs_config contains <> end type process_phs_config_t @ %def process_phs_config_t @ Output, DTIO compatible. <>= procedure :: write => process_phs_config_write procedure :: write_formatted => process_phs_config_write_formatted ! generic :: write (formatted) => write_formatted <>= module subroutine process_phs_config_write (phs_config, unit) class(process_phs_config_t), intent(in) :: phs_config integer, intent(in), optional :: unit end subroutine process_phs_config_write <>= module subroutine process_phs_config_write (phs_config, unit) class(process_phs_config_t), intent(in) :: phs_config integer, intent(in), optional :: unit integer :: u, iostat integer, dimension(:), allocatable :: v_list character(0) :: iomsg u = given_output_unit (unit) allocate (v_list (0)) call phs_config%write_formatted (u, "LISTDIRECTED", v_list, iostat, iomsg) end subroutine process_phs_config_write @ %def process_phs_config_write @ DTIO standard write. <>= module subroutine process_phs_config_write_formatted & (dtv, unit, iotype, v_list, iostat, iomsg) class(process_phs_config_t), intent(in) :: dtv integer, intent(in) :: unit character(*), intent(in) :: iotype integer, dimension(:), intent(in) :: v_list integer, intent(out) :: iostat character(*), intent(inout) :: iomsg end subroutine process_phs_config_write_formatted <>= module subroutine process_phs_config_write_formatted & (dtv, unit, iotype, v_list, iostat, iomsg) class(process_phs_config_t), intent(in) :: dtv integer, intent(in) :: unit character(*), intent(in) :: iotype integer, dimension(:), intent(in) :: v_list integer, intent(out) :: iostat character(*), intent(inout) :: iomsg associate (phs_config => dtv) write (unit, "(1x, A)") "Phase-space configuration entry:" call phs_config%phs_par%write (unit) call phs_config%mapping_defs%write (unit) end associate iostat = 0 end subroutine process_phs_config_write_formatted @ %def process_phs_config_write_formatted @ \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]] is obvious. <>= public :: process_beam_config_t <>= 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 = .true. character(32) :: md5sum = "" logical :: sf_trace = .false. type(string_t) :: sf_trace_file contains <> 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. <>= procedure :: write => process_beam_config_write <>= module 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 end subroutine process_beam_config_write <>= module 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 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. <>= procedure :: final => process_beam_config_final <>= module subroutine process_beam_config_final (object) class(process_beam_config_t), intent(inout) :: object end subroutine process_beam_config_final <>= module 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. <>= procedure :: init_beam_structure => process_beam_config_init_beam_structure <>= module 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 end subroutine process_beam_config_init_beam_structure <>= module 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 = beam_config%data%lab_is_cm 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). <>= procedure :: init_scattering => process_beam_config_init_scattering <>= module 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 end subroutine process_beam_config_init_scattering <>= module 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. <>= procedure :: init_decay => process_beam_config_init_decay <>= module 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 end subroutine process_beam_config_init_decay <>= module 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 = beam_config%data%lab_is_cm end subroutine process_beam_config_init_decay @ %def process_beam_config_init_decay @ Print an informative message. <>= procedure :: startup_message => process_beam_config_startup_message <>= module 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 end subroutine process_beam_config_startup_message <>= module 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. <>= procedure :: init_sf_chain => process_beam_config_init_sf_chain <>= module 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 end subroutine process_beam_config_init_sf_chain <>= module 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. <>= procedure :: allocate_sf_channels => process_beam_config_allocate_sf_channels <>= module 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 end subroutine process_beam_config_allocate_sf_channels <>= module 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.) <>= procedure :: set_sf_channel => process_beam_config_set_sf_channel <>= module 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 end subroutine process_beam_config_set_sf_channel <>= module 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. <>= procedure :: sf_startup_message => process_beam_config_sf_startup_message <>= module 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 end subroutine process_beam_config_sf_startup_message <>= module 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 does not work correctly.) <>= procedure :: get_pdf_set => process_beam_config_get_pdf_set <>= module function process_beam_config_get_pdf_set & (beam_config) result (pdf_set) class(process_beam_config_t), intent(in) :: beam_config integer :: pdf_set end function process_beam_config_get_pdf_set <>= module 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. <>= procedure :: get_beam_file => process_beam_config_get_beam_file <>= module function process_beam_config_get_beam_file & (beam_config) result (file) class(process_beam_config_t), intent(in) :: beam_config type(string_t) :: file end function process_beam_config_get_beam_file <>= module 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. <>= procedure :: compute_md5sum => process_beam_config_compute_md5sum <>= module subroutine process_beam_config_compute_md5sum (beam_config) class(process_beam_config_t), intent(inout) :: beam_config end subroutine process_beam_config_compute_md5sum <>= module 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 @ <>= procedure :: get_md5sum => process_beam_config_get_md5sum <>= pure module function process_beam_config_get_md5sum & (beam_config) result (md5) character(32) :: md5 class(process_beam_config_t), intent(in) :: beam_config end function process_beam_config_get_md5sum <>= pure module 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 @ <>= procedure :: has_structure_function => & process_beam_config_has_structure_function <>= pure module function process_beam_config_has_structure_function & (beam_config) result (has_sf) logical :: has_sf class(process_beam_config_t), intent(in) :: beam_config end function process_beam_config_has_structure_function <>= pure module 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. <>= public :: process_component_t <>= type :: process_component_t type(process_component_def_t), pointer :: config => null () integer :: index = 0 logical :: active = .false. 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 <> 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. <>= procedure :: final => process_component_final <>= module subroutine process_component_final (object) class(process_component_t), intent(inout) :: object end subroutine process_component_final <>= module subroutine process_component_final (object) class(process_component_t), intent(inout) :: object 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. <>= procedure :: write => process_component_write <>= module subroutine process_component_write (object, unit) class(process_component_t), intent(in) :: object integer, intent(in), optional :: unit end subroutine process_component_write <>= module 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. <>= procedure :: init => process_component_init <>= module subroutine process_component_init (component, & i_component, env, meta, config, & active, & phs_config_template) class(process_component_t), intent(out) :: component integer, intent(in) :: i_component type(process_environment_t), intent(in) :: env type(process_metadata_t), intent(in) :: meta type(process_config_data_t), intent(in) :: config logical, intent(in) :: active class(phs_config_t), intent(in), allocatable :: phs_config_template end subroutine process_component_init <>= module subroutine process_component_init (component, & i_component, env, meta, config, & active, & phs_config_template) class(process_component_t), intent(out) :: component integer, intent(in) :: i_component type(process_environment_t), intent(in) :: env type(process_metadata_t), intent(in) :: meta type(process_config_data_t), intent(in) :: config logical, intent(in) :: active class(phs_config_t), intent(in), allocatable :: phs_config_template type(process_constants_t) :: data component%index = i_component component%config => & config%process_def%get_component_def_ptr (i_component) component%active = active if (component%active) then allocate (component%phs_config, source = phs_config_template) call env%fill_process_constants (meta%id, i_component, data) call component%phs_config%init (data, config%model) end if end subroutine process_component_init @ %def process_component_init @ <>= procedure :: is_active => process_component_is_active <>= elemental module function process_component_is_active & (component) result (active) logical :: active class(process_component_t), intent(in) :: component end function process_component_is_active <>= elemental module 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 @ Finalize the phase-space configuration. <>= procedure :: configure_phs => process_component_configure_phs <>= module 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 end subroutine process_component_configure_phs <>= module 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, & lab_is_cm = beam_config%lab_is_cm .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. <>= procedure :: compute_md5sum => process_component_compute_md5sum <>= module subroutine process_component_compute_md5sum (component) class(process_component_t), intent(inout) :: component end subroutine process_component_compute_md5sum <>= module 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. <>= procedure :: collect_channels => process_component_collect_channels <>= module subroutine process_component_collect_channels (component, coll) class(process_component_t), intent(inout) :: component type(phs_channel_collection_t), intent(inout) :: coll end subroutine process_component_collect_channels <>= module 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 @ <>= procedure :: get_config => process_component_get_config <>= module function process_component_get_config (component) & result (config) type(process_component_def_t) :: config class(process_component_t), intent(in) :: component end function process_component_get_config <>= module 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 @ <>= procedure :: get_md5sum => process_component_get_md5sum <>= pure module function process_component_get_md5sum (component) result (md5) type(string_t) :: md5 class(process_component_t), intent(in) :: component end function process_component_get_md5sum <>= pure module 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. <>= procedure :: get_n_phs_par => process_component_get_n_phs_par <>= module function process_component_get_n_phs_par (component) result (n_par) class(process_component_t), intent(in) :: component integer :: n_par end function process_component_get_n_phs_par <>= module 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 @ <>= procedure :: get_phs_config => process_component_get_phs_config <>= module 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 end subroutine process_component_get_phs_config <>= module 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 @ <>= procedure :: get_nlo_type => process_component_get_nlo_type <>= elemental module function process_component_get_nlo_type & (component) result (nlo_type) integer :: nlo_type class(process_component_t), intent(in) :: component end function process_component_get_nlo_type <>= elemental module 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 @ <>= procedure :: needs_mci_entry => process_component_needs_mci_entry <>= module 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 end function process_component_needs_mci_entry <>= module 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 @ <>= procedure :: can_be_integrated => process_component_can_be_integrated <>= elemental module function process_component_can_be_integrated & (component) result (active) logical :: active class(process_component_t), intent(in) :: component end function process_component_can_be_integrated <>= elemental module 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. <>= public :: process_term_t <>= 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 () contains <> 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. <>= procedure :: write => process_term_write <>= module subroutine process_term_write (term, unit) class(process_term_t), intent(in) :: term integer, intent(in), optional :: unit end subroutine process_term_write <>= module 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. <>= procedure :: write_state_summary => process_term_write_state_summary <>= module 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 end subroutine process_term_write_state_summary <>= module 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. <>= procedure :: final => process_term_final <>= module subroutine process_term_final (term) class(process_term_t), intent(inout) :: term end subroutine process_term_final <>= module 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 an 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. <>= procedure :: init => process_term_init <>= module subroutine process_term_init & (term, i_term_global, i_component, i_term, core, model, & nlo_type, use_beam_pol, subtraction_method, & has_pdfs, n_emitters) 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 logical, intent(in), optional :: has_pdfs integer, intent(in), optional :: n_emitters end subroutine process_term_init <>= module subroutine process_term_init & (term, i_term_global, i_component, i_term, core, model, & nlo_type, use_beam_pol, subtraction_method, & has_pdfs, n_emitters) 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 logical, intent(in), optional :: has_pdfs integer, intent(in), optional :: n_emitters 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, & has_pdfs = has_pdfs, n_emitters = n_emitters) 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 \to -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)$. The [[n_emitters]] optional argument is provided by the caller if this term requires spin-correlated matrix elements, and thus involves additional subtractions. <>= procedure :: setup_interaction => process_term_setup_interaction <>= module subroutine process_term_setup_interaction (term, core, model, & nlo_type, pol_beams, has_pdfs, use_internal_color, n_emitters) 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 logical, intent(in), optional :: has_pdfs integer, intent(in), optional :: nlo_type logical, intent(in), optional :: use_internal_color integer, intent(in), optional :: n_emitters end subroutine process_term_setup_interaction <>= module subroutine process_term_setup_interaction (term, core, model, & nlo_type, pol_beams, has_pdfs, use_internal_color, n_emitters) 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 logical, intent(in), optional :: has_pdfs integer, intent(in), optional :: nlo_type logical, intent(in), optional :: use_internal_color integer, intent(in), optional :: n_emitters 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 (n_emitters, has_pdfs) call fill_quantum_numbers () call term%int%basic_init & (term%data%n_in, 0, term%data%n_out, set_relations = .true.) select type (core) class is (prc_blha_t) call setup_states_blha_olp () type is (prc_threshold_t) call setup_states_threshold () class is (prc_external_t) call setup_states_other_prc_external () 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_external_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 (n_emitters, has_pdfs) integer, intent(in), optional :: n_emitters logical, intent(in), optional :: has_pdfs 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 .or. nlo_t == NLO_DGLAP 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 if (present (n_emitters)) then n_sub_spin = 6 * n_emitters end if 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 (present (has_pdfs)) then if (has_pdfs & .and. ((nlo_t == NLO_REAL .and. can_have_sub) & .or. nlo_t == NLO_DGLAP)) then !!! necessary dummy, needs refactoring, !!! c.f. [[term_instance_evaluate_interaction_external_tree]] n_sub = n_sub + n_beams_rescaled end if 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_external_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_blha_olp () 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 select type (core) type is (prc_openloops_t) call hel%init (data%hel_state (:,h)) call qn%init (flv, hel, col, s) class default call msg_fatal ("Polarized beams only supported by OpenLoops") end select 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_blha_olp 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_prc_external () integer :: s, f, i, c, h 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 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 () call qn%init (flv, col, s) 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_other_prc_external 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 @ <>= procedure :: get_process_constants => process_term_get_process_constants <>= module subroutine process_term_get_process_constants & (term, prc_constants) class(process_term_t), intent(inout) :: term type(process_constants_t), intent(out) :: prc_constants end subroutine process_term_get_process_constants <>= module 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]]>>= <> module process_counter <> <> <> <> interface <> end interface 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. <>= public :: process_counter_t <>= 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 <> end type process_counter_t @ %def process_counter_t @ Here are the corresponding numeric codes: <>= 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. <>= procedure :: write => process_counter_write <>= module subroutine process_counter_write (object, unit) class(process_counter_t), intent(in) :: object integer, intent(in), optional :: unit end subroutine process_counter_write <>= module 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 @ <<[[process_counter_sub.f90]]>>= <> submodule (process_counter) process_counter_s use io_units implicit none contains <> end submodule process_counter_s @ %def process_counter_s @ Reset. Just enforce default initialization. <>= procedure :: reset => process_counter_reset <>= module subroutine process_counter_reset (counter) class(process_counter_t), intent(out) :: counter end subroutine process_counter_reset <>= module 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. <>= procedure :: record => process_counter_record <>= module subroutine process_counter_record (counter, status) class(process_counter_t), intent(inout) :: counter integer, intent(in) :: status end subroutine process_counter_record <>= module 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]]>>= <> module process_mci <> <> 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 <> <> <> <> interface <> end interface end module process_mci @ %def process_mci @ <<[[process_mci_sub.f90]]>>= <> submodule (process_mci) process_mci_s <> use io_units use diagnostics use physics_defs use md5 implicit none contains <> end submodule process_mci_s @ %def process_mci_s \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. <>= public :: process_mci_entry_t <>= 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 = .false. logical :: combined_integration = .false. integer :: real_partition_type = REAL_FULL contains <> end type process_mci_entry_t @ %def process_mci_entry_t @ Finalizer for the [[mci]] component. <>= procedure :: final => process_mci_entry_final <>= module subroutine process_mci_entry_final (object) class(process_mci_entry_t), intent(inout) :: object end subroutine process_mci_entry_final <>= module 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. <>= procedure :: write => process_mci_entry_write <>= module 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 end subroutine process_mci_entry_write <>= module 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 @ Configure the MCI entry. This is intent(inout) since some specific settings may be done before this. The actual [[mci_t]] object is an instance of the [[mci_template]] argument, which determines the concrete types. In a unit-test context, the [[mci_template]] argument may be unallocated. 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. We assume that there is only one process component directly associated with an MCI entry. <>= procedure :: configure => process_mci_entry_configure <>= module subroutine process_mci_entry_configure (mci_entry, mci_template, & process_type, i_mci, i_component, component, & n_sfpar, rng_factory) class(process_mci_entry_t), intent(inout) :: mci_entry class(mci_t), intent(in), allocatable :: mci_template 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 end subroutine process_mci_entry_configure <>= module subroutine process_mci_entry_configure (mci_entry, mci_template, & process_type, i_mci, i_component, component, & n_sfpar, rng_factory) class(process_mci_entry_t), intent(inout) :: mci_entry class(mci_t), intent(in), allocatable :: mci_template 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 (allocated (mci_template)) then allocate (mci_entry%mci, source = 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_configure @ %def process_mci_entry_configure @ <>= integer, parameter, public :: REAL_FULL = 0 integer, parameter, public :: REAL_SINGULAR = 1 integer, parameter, public :: REAL_FINITE = 2 @ <>= procedure :: create_component_list => & process_mci_entry_create_component_list <>= module 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 end subroutine process_mci_entry_create_component_list <>= module 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 if (debug_on) call msg_debug & (D_PROCESS_INTEGRATION, "process_mci_entry_create_component_list") if (mci_entry%combined_integration) then if (debug_on) call msg_debug (D_PROCESS_INTEGRATION, & "mci_entry%real_partition_type", mci_entry%real_partition_type) n = get_n_components (mci_entry%real_partition_type) allocate (i_list (n)) 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 (real_partition_type) result (n_components) integer :: n_components integer, intent(in) :: real_partition_type select case (real_partition_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 if (debug_on) 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 @ Set some additional parameters. <>= procedure :: set_parameters => process_mci_entry_set_parameters <>= module 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 end subroutine process_mci_entry_set_parameters <>= module 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. <>= procedure :: compute_md5sum => process_mci_entry_compute_md5sum <>= module 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 end subroutine process_mci_entry_compute_md5sum <>= module 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. <>= procedure :: sampler_test => process_mci_entry_sampler_test <>= module 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 end subroutine process_mci_entry_sampler_test <>= module 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. <>= procedure :: integrate => process_mci_entry_integrate procedure :: final_integration => process_mci_entry_final_integration <>= module 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 end subroutine process_mci_entry_integrate module subroutine process_mci_entry_final_integration (mci_entry) class(process_mci_entry_t), intent(inout) :: mci_entry end subroutine process_mci_entry_final_integration <>= module 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 module 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. <>= procedure :: get_time => process_mci_entry_get_time procedure :: time_message => process_mci_entry_time_message <>= module 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 end subroutine process_mci_entry_get_time module subroutine process_mci_entry_time_message (mci_entry) class(process_mci_entry_t), intent(in) :: mci_entry end subroutine process_mci_entry_time_message <>= module 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 module 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.) <>= procedure :: prepare_simulation => process_mci_entry_prepare_simulation <>= module subroutine process_mci_entry_prepare_simulation (mci_entry) class(process_mci_entry_t), intent(inout) :: mci_entry end subroutine process_mci_entry_prepare_simulation <>= module 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. The [[keep_failed]] flag determines whether events which failed cuts are nevertheless produced, to be recorded with zero weight. Alternatively, failed events are dropped, and this fact is recorded by the counter [[n_dropped]]. <>= procedure :: generate_weighted_event => & process_mci_entry_generate_weighted_event procedure :: generate_unweighted_event => & process_mci_entry_generate_unweighted_event <>= module 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 end subroutine process_mci_entry_generate_weighted_event module 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 end subroutine process_mci_entry_generate_unweighted_event <>= module 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. call mci_instance%reset_n_event_dropped () 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 call mci_instance%record_event_dropped () generate_new = .true. end if else generate_new = .false. end if end do REJECTION end subroutine process_mci_entry_generate_weighted_event module 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. <>= 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 <>= module function process_mci_entry_has_integral (mci_entry) result (flag) class(process_mci_entry_t), intent(in) :: mci_entry logical :: flag end function process_mci_entry_has_integral module function process_mci_entry_get_integral (mci_entry) result (integral) class(process_mci_entry_t), intent(in) :: mci_entry real(default) :: integral end function process_mci_entry_get_integral module function process_mci_entry_get_error (mci_entry) result (error) class(process_mci_entry_t), intent(in) :: mci_entry real(default) :: error end function process_mci_entry_get_error module function process_mci_entry_get_accuracy (mci_entry) result (accuracy) class(process_mci_entry_t), intent(in) :: mci_entry real(default) :: accuracy end function process_mci_entry_get_accuracy module function process_mci_entry_get_chi2 (mci_entry) result (chi2) class(process_mci_entry_t), intent(in) :: mci_entry real(default) :: chi2 end function process_mci_entry_get_chi2 module function process_mci_entry_get_efficiency & (mci_entry) result (efficiency) class(process_mci_entry_t), intent(in) :: mci_entry real(default) :: efficiency end function process_mci_entry_get_efficiency <>= module 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 module 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 module 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 module 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 module 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 module 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). <>= procedure :: get_md5sum => process_mci_entry_get_md5sum <>= pure module function process_mci_entry_get_md5sum (entry) result (md5sum) class(process_mci_entry_t), intent(in) :: entry character(32) :: md5sum end function process_mci_entry_get_md5sum <>= pure module 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. <>= public :: mci_work_t <>= 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. integer :: n_event_dropped = 0 contains <> end type mci_work_t @ %def mci_work_t @ First write configuration data, then the current values. <>= procedure :: write => mci_work_write <>= module 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 end subroutine mci_work_write <>= module 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. <>= procedure :: final => mci_work_final <>= module subroutine mci_work_final (mci_work) class(mci_work_t), intent(inout) :: mci_work end subroutine mci_work_final <>= module 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. <>= procedure :: init => mci_work_init <>= module 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 end subroutine mci_work_init <>= module 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. <>= procedure :: set => mci_work_set procedure :: set_x_strfun => mci_work_set_x_strfun procedure :: set_x_process => mci_work_set_x_process <>= module subroutine mci_work_set (mci_work, x) class(mci_work_t), intent(inout) :: mci_work real(default), dimension(:), intent(in) :: x end subroutine mci_work_set module subroutine mci_work_set_x_strfun (mci_work, x) class(mci_work_t), intent(inout) :: mci_work real(default), dimension(:), intent(in) :: x end subroutine mci_work_set_x_strfun module subroutine mci_work_set_x_process (mci_work, x) class(mci_work_t), intent(inout) :: mci_work real(default), dimension(:), intent(in) :: x end subroutine mci_work_set_x_process <>= module 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 module 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 module 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. <>= procedure :: get_active_components => mci_work_get_active_components <>= module function mci_work_get_active_components & (mci_work) result (i_component) class(mci_work_t), intent(in) :: mci_work integer, dimension(:), allocatable :: i_component end function mci_work_get_active_components <>= module 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. <>= procedure :: get_x_strfun => mci_work_get_x_strfun procedure :: get_x_process => mci_work_get_x_process <>= pure module 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 end function mci_work_get_x_strfun pure module 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 end function mci_work_get_x_process <>= pure module 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 module 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. <>= procedure :: init_simulation => mci_work_init_simulation procedure :: final_simulation => mci_work_final_simulation <>= module subroutine mci_work_final_simulation (mci_work) class(mci_work_t), intent(inout) :: mci_work end subroutine mci_work_final_simulation module 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 end subroutine mci_work_init_simulation <>= module 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 module 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. <>= procedure :: reset_counter => mci_work_reset_counter procedure :: record_call => mci_work_record_call procedure :: get_counter => mci_work_get_counter <>= module subroutine mci_work_reset_counter (mci_work) class(mci_work_t), intent(inout) :: mci_work end subroutine mci_work_reset_counter module subroutine mci_work_record_call (mci_work, status) class(mci_work_t), intent(inout) :: mci_work integer, intent(in) :: status end subroutine mci_work_record_call pure module function mci_work_get_counter (mci_work) result (counter) class(mci_work_t), intent(in) :: mci_work type(process_counter_t) :: counter end function mci_work_get_counter <>= module 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 module 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 module 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]]>>= <> module pcm <> <> use lorentz use model_data, only: model_data_t use models, only: model_t use quantum_numbers, only: quantum_numbers_t, quantum_numbers_mask_t use variables, only: var_list_t use nlo_data, only: nlo_settings_t use nlo_data, only: fks_template_t use nlo_data, only: FKS_DEFAULT, FKS_RESONANCES use mci_base, only: mci_t use phs_base, only: phs_config_t use mappings, only: mapping_defaults_t use phs_forests, only: phs_parameters_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 phs_fks, only: phs_fks_config_t, get_filtered_resonance_histories use dispatch_phase_space, only: dispatch_phs use real_subtraction, only: real_subtraction_t, soft_mismatch_t use real_subtraction, only: INTEGRATION, FIXED_ORDER_EVENTS 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 blha_config, only: blha_master_t use pcm_base use process_config use process_mci, only: process_mci_entry_t use process_mci, only: REAL_SINGULAR, REAL_FINITE <> <> <> interface <> end interface contains <> end module pcm @ %def pcm @ <<[[pcm_sub.f90]]>>= <> submodule (pcm) pcm_s <> use constants, only: zero, two use diagnostics use phs_points, only: assignment(=) use io_units, only: free_unit use os_interface use process_constants, only: process_constants_t use physics_defs use flavors, only: flavor_t use interactions, only: interaction_t use dispatch_fks, only: dispatch_fks_setup use process_libraries, only: process_component_def_t use resonances, only: resonance_history_t, resonance_history_set_t use prc_threshold, only: threshold_def_t use blha_olp_interfaces, only: prc_blha_t implicit none contains <> end submodule pcm_s @ %def pcm_s @ \subsection{Default process component manager} This is the configuration object which has the duty of allocating the corresponding instance. The default version is trivial. <>= public :: pcm_default_t <>= type, extends (pcm_t) :: pcm_default_t contains <> end type pcm_default_t @ %def pcm_default_t Gfortran 7/8/9 bug, has to remain in the main module: <>= procedure :: allocate_workspace => pcm_default_allocate_workspace <>= subroutine pcm_default_allocate_workspace (pcm, work) class(pcm_default_t), intent(in) :: pcm class(pcm_workspace_t), intent(inout), allocatable :: work allocate (pcm_default_workspace_t :: work) end subroutine pcm_default_allocate_workspace @ %def pcm_default_allocate_workspace @ Finalizer: apply to core manager. <>= procedure :: final => pcm_default_final <>= module subroutine pcm_default_final (pcm) class(pcm_default_t), intent(inout) :: pcm end subroutine pcm_default_final <>= module subroutine pcm_default_final (pcm) class(pcm_default_t), intent(inout) :: pcm end subroutine pcm_default_final @ %def pcm_default_final @ <>= procedure :: is_nlo => pcm_default_is_nlo <>= module function pcm_default_is_nlo (pcm) result (is_nlo) logical :: is_nlo class(pcm_default_t), intent(in) :: pcm end function pcm_default_is_nlo <>= module 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 @ Initialize configuration data, using environment variables. <>= procedure :: init => pcm_default_init <>= module subroutine pcm_default_init (pcm, env, meta) class(pcm_default_t), intent(out) :: pcm type(process_environment_t), intent(in) :: env type(process_metadata_t), intent(in) :: meta end subroutine pcm_default_init <>= module subroutine pcm_default_init (pcm, env, meta) class(pcm_default_t), intent(out) :: pcm type(process_environment_t), intent(in) :: env type(process_metadata_t), intent(in) :: meta pcm%has_pdfs = env%has_pdfs () call pcm%set_blha_defaults & (env%has_polarized_beams (), env%get_var_list_ptr ()) pcm%os_data = env%get_os_data () end subroutine pcm_default_init @ %def pcm_default_init @ <>= type, extends (pcm_workspace_t) :: pcm_default_workspace_t contains <> end type pcm_default_workspace_t @ %def pcm_default_workspace_t @ <>= procedure :: final => pcm_default_workspace_final <>= module subroutine pcm_default_workspace_final (pcm_work) class(pcm_default_workspace_t), intent(inout) :: pcm_work end subroutine pcm_default_workspace_final <>= module subroutine pcm_default_workspace_final (pcm_work) class(pcm_default_workspace_t), intent(inout) :: pcm_work end subroutine pcm_default_workspace_final @ %def pcm_default_workspace_final @ <>= procedure :: is_nlo => pcm_default_workspace_is_nlo <>= module function pcm_default_workspace_is_nlo (pcm_work) result (is_nlo) logical :: is_nlo class(pcm_default_workspace_t), intent(inout) :: pcm_work end function pcm_default_workspace_is_nlo <>= module function pcm_default_workspace_is_nlo (pcm_work) result (is_nlo) logical :: is_nlo class(pcm_default_workspace_t), intent(inout) :: pcm_work is_nlo = .false. end function pcm_default_workspace_is_nlo @ %def pcm_default_workspace_is_nlo @ \subsection{Implementations for the default manager} Categorize components. Nothing to do here, all components are of Born type. <>= procedure :: categorize_components => pcm_default_categorize_components <>= module subroutine pcm_default_categorize_components (pcm, config) class(pcm_default_t), intent(inout) :: pcm type(process_config_data_t), intent(in) :: config end subroutine pcm_default_categorize_components <>= module subroutine pcm_default_categorize_components (pcm, config) class(pcm_default_t), intent(inout) :: pcm type(process_config_data_t), intent(in) :: config end subroutine pcm_default_categorize_components @ %def pcm_default_categorize_components @ \subsubsection{Phase-space configuration} Default setup for tree processes: a single phase-space configuration that is valid for all components. <>= procedure :: init_phs_config => pcm_default_init_phs_config <>= module subroutine pcm_default_init_phs_config & (pcm, phs_entry, meta, env, phs_par, mapping_defs) class(pcm_default_t), intent(inout) :: pcm type(process_phs_config_t), & dimension(:), allocatable, intent(out) :: phs_entry type(process_metadata_t), intent(in) :: meta type(process_environment_t), intent(in) :: env type(mapping_defaults_t), intent(in) :: mapping_defs type(phs_parameters_t), intent(in) :: phs_par end subroutine pcm_default_init_phs_config <>= module subroutine pcm_default_init_phs_config & (pcm, phs_entry, meta, env, phs_par, mapping_defs) class(pcm_default_t), intent(inout) :: pcm type(process_phs_config_t), & dimension(:), allocatable, intent(out) :: phs_entry type(process_metadata_t), intent(in) :: meta type(process_environment_t), intent(in) :: env type(mapping_defaults_t), intent(in) :: mapping_defs type(phs_parameters_t), intent(in) :: phs_par allocate (phs_entry (1)) allocate (pcm%i_phs_config (pcm%n_components), source=1) call dispatch_phs (phs_entry(1)%phs_config, & env%get_var_list_ptr (), & env%get_os_data (), & meta%id, & mapping_defs, phs_par) end subroutine pcm_default_init_phs_config @ %def pcm_default_init_phs_config @ \subsubsection{Core management} The default component manager assigns one core per component. We allocate and configure the core objects, using the process-component configuration data. <>= procedure :: allocate_cores => pcm_default_allocate_cores <>= module subroutine pcm_default_allocate_cores (pcm, config, core_entry) class(pcm_default_t), intent(inout) :: pcm type(process_config_data_t), intent(in) :: config type(core_entry_t), dimension(:), allocatable, intent(out) :: core_entry end subroutine pcm_default_allocate_cores <>= module subroutine pcm_default_allocate_cores (pcm, config, core_entry) class(pcm_default_t), intent(inout) :: pcm type(process_config_data_t), intent(in) :: config type(core_entry_t), dimension(:), allocatable, intent(out) :: core_entry type(process_component_def_t), pointer :: component_def integer :: i allocate (pcm%i_core (pcm%n_components), source = 0) pcm%n_cores = pcm%n_components allocate (core_entry (pcm%n_cores)) do i = 1, pcm%n_cores pcm%i_core(i) = i core_entry(i)%i_component = i component_def => config%process_def%get_component_def_ptr (i) core_entry(i)%core_def => component_def%get_core_def_ptr () core_entry(i)%active = component_def%can_be_integrated () end do end subroutine pcm_default_allocate_cores @ %def pcm_default_allocate_cores @ Extra code is required for certain core types (threshold) or if BLHA uses an external OLP (Born only, this case) for getting its matrix elements. <>= procedure :: prepare_any_external_code => & pcm_default_prepare_any_external_code <>= module subroutine pcm_default_prepare_any_external_code & (pcm, core_entry, i_core, libname, model, var_list) class(pcm_default_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry integer, intent(in) :: i_core type(string_t), intent(in) :: libname type(model_data_t), intent(in), target :: model type(var_list_t), intent(in) :: var_list end subroutine pcm_default_prepare_any_external_code <>= module subroutine pcm_default_prepare_any_external_code & (pcm, core_entry, i_core, libname, model, var_list) class(pcm_default_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry integer, intent(in) :: i_core type(string_t), intent(in) :: libname type(model_data_t), intent(in), target :: model type(var_list_t), intent(in) :: var_list if (core_entry%active) then associate (core => core_entry%core) if (core%needs_external_code ()) then call core%prepare_external_code & (core%data%flv_state, & var_list, pcm%os_data, libname, model, i_core, .false.) end if call core%set_equivalent_flv_hel_indices () end associate end if end subroutine pcm_default_prepare_any_external_code @ %def pcm_default_prepare_any_external_code @ Allocate and configure the BLHA record for a specific core, assuming that the core type requires it. In the default case, this is a Born configuration. <>= procedure :: setup_blha => pcm_default_setup_blha <>= module subroutine pcm_default_setup_blha (pcm, core_entry) class(pcm_default_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry end subroutine pcm_default_setup_blha <>= module subroutine pcm_default_setup_blha (pcm, core_entry) class(pcm_default_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry allocate (core_entry%blha_config, source = pcm%blha_defaults) call core_entry%blha_config%set_born () end subroutine pcm_default_setup_blha @ %def pcm_default_setup_blha @ Apply the configuration, using [[pcm]] data. <>= procedure :: prepare_blha_core => pcm_default_prepare_blha_core <>= module subroutine pcm_default_prepare_blha_core (pcm, core_entry, model) class(pcm_default_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry class(model_data_t), intent(in), target :: model end subroutine pcm_default_prepare_blha_core <>= module subroutine pcm_default_prepare_blha_core (pcm, core_entry, model) class(pcm_default_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry class(model_data_t), intent(in), target :: model integer :: n_in integer :: n_legs integer :: n_flv integer :: n_hel select type (core => core_entry%core) class is (prc_blha_t) associate (blha_config => core_entry%blha_config) n_in = core%data%n_in n_legs = core%data%get_n_tot () n_flv = core%data%n_flv n_hel = blha_config%get_n_hel (core%data%flv_state (1:n_in,1), model) call core%init_blha (blha_config, n_in, n_legs, n_flv, n_hel) call core%init_driver (pcm%os_data) end associate end select end subroutine pcm_default_prepare_blha_core @ %def pcm_default_prepare_blha_core @ Read the method settings from the variable list and store them in the BLHA master. This version: no NLO flag. <>= procedure :: set_blha_methods => pcm_default_set_blha_methods <>= module subroutine pcm_default_set_blha_methods (pcm, blha_master, var_list) class(pcm_default_t), intent(inout) :: pcm type(blha_master_t), intent(inout) :: blha_master type(var_list_t), intent(in) :: var_list end subroutine pcm_default_set_blha_methods <>= module subroutine pcm_default_set_blha_methods (pcm, blha_master, var_list) class(pcm_default_t), intent(inout) :: pcm type(blha_master_t), intent(inout) :: blha_master type(var_list_t), intent(in) :: var_list call blha_master%set_methods (.false., var_list) end subroutine pcm_default_set_blha_methods @ %def pcm_default_set_blha_methods @ Produce the LO and NLO flavor-state tables (as far as available), as appropriate for BLHA configuration. The default version looks at the first process core only, to get the Born data. (Multiple cores are thus unsupported.) The NLO flavor table is left unallocated. <>= procedure :: get_blha_flv_states => pcm_default_get_blha_flv_states <>= module subroutine pcm_default_get_blha_flv_states & (pcm, core_entry, flv_born, flv_real) class(pcm_default_t), intent(in) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry integer, dimension(:,:), allocatable, intent(out) :: flv_born integer, dimension(:,:), allocatable, intent(out) :: flv_real end subroutine pcm_default_get_blha_flv_states <>= module subroutine pcm_default_get_blha_flv_states & (pcm, core_entry, flv_born, flv_real) class(pcm_default_t), intent(in) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry integer, dimension(:,:), allocatable, intent(out) :: flv_born integer, dimension(:,:), allocatable, intent(out) :: flv_real flv_born = core_entry(1)%core%data%flv_state end subroutine pcm_default_get_blha_flv_states @ %def pcm_default_get_blha_flv_states @ Allocate and configure the MCI (multi-channel integrator) records. There is one record per active process component. Second procedure: call the MCI dispatcher with default-setup arguments. <>= procedure :: setup_mci => pcm_default_setup_mci procedure :: call_dispatch_mci => pcm_default_call_dispatch_mci <>= module subroutine pcm_default_setup_mci (pcm, mci_entry) class(pcm_default_t), intent(inout) :: pcm type(process_mci_entry_t), & dimension(:), allocatable, intent(out) :: mci_entry end subroutine pcm_default_setup_mci module subroutine pcm_default_call_dispatch_mci (pcm, & dispatch_mci, var_list, process_id, mci_template) class(pcm_default_t), intent(inout) :: pcm procedure(dispatch_mci_proc) :: dispatch_mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id class(mci_t), allocatable, intent(out) :: mci_template end subroutine pcm_default_call_dispatch_mci <>= module subroutine pcm_default_setup_mci (pcm, mci_entry) class(pcm_default_t), intent(inout) :: pcm type(process_mci_entry_t), & dimension(:), allocatable, intent(out) :: mci_entry class(mci_t), allocatable :: mci_template integer :: i, i_mci pcm%n_mci = count (pcm%component_active) allocate (pcm%i_mci (pcm%n_components), source = 0) i_mci = 0 do i = 1, pcm%n_components if (pcm%component_active(i)) then i_mci = i_mci + 1 pcm%i_mci(i) = i_mci end if end do allocate (mci_entry (pcm%n_mci)) end subroutine pcm_default_setup_mci module subroutine pcm_default_call_dispatch_mci (pcm, & dispatch_mci, var_list, process_id, mci_template) class(pcm_default_t), intent(inout) :: pcm procedure(dispatch_mci_proc) :: dispatch_mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id class(mci_t), allocatable, intent(out) :: mci_template call dispatch_mci (mci_template, var_list, process_id) end subroutine pcm_default_call_dispatch_mci @ %def pcm_default_setup_mci @ %def pcm_default_call_dispatch_mci @ Nothing left to do for the default algorithm. <>= procedure :: complete_setup => pcm_default_complete_setup <>= module subroutine pcm_default_complete_setup & (pcm, core_entry, component, model) class(pcm_default_t), intent(inout) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry type(process_component_t), dimension(:), intent(inout) :: component type(model_t), intent(in), target :: model end subroutine pcm_default_complete_setup <>= module subroutine pcm_default_complete_setup & (pcm, core_entry, component, model) class(pcm_default_t), intent(inout) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry type(process_component_t), dimension(:), intent(inout) :: component type(model_t), intent(in), target :: model end subroutine pcm_default_complete_setup @ %def pcm_default_complete_setup @ \subsubsection{Component management} Initialize a single component. We require all process-configuration blocks, and specific templates for the phase-space and integrator configuration. We also provide the current component index [[i]] and the [[active]] flag. In the default mode, all components are marked as master components. <>= procedure :: init_component => pcm_default_init_component <>= module subroutine pcm_default_init_component (pcm, component, i, active, & phs_config, env, meta, config) class(pcm_default_t), intent(in) :: pcm type(process_component_t), intent(out) :: component integer, intent(in) :: i logical, intent(in) :: active class(phs_config_t), allocatable, intent(in) :: phs_config type(process_environment_t), intent(in) :: env type(process_metadata_t), intent(in) :: meta type(process_config_data_t), intent(in) :: config end subroutine pcm_default_init_component <>= module subroutine pcm_default_init_component (pcm, component, i, active, & phs_config, env, meta, config) class(pcm_default_t), intent(in) :: pcm type(process_component_t), intent(out) :: component integer, intent(in) :: i logical, intent(in) :: active class(phs_config_t), allocatable, intent(in) :: phs_config type(process_environment_t), intent(in) :: env type(process_metadata_t), intent(in) :: meta type(process_config_data_t), intent(in) :: config call component%init (i, & env, meta, config, & active, & phs_config) component%component_type = COMP_MASTER end subroutine pcm_default_init_component @ %def pcm_default_init_component @ \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. <>= public :: pcm_nlo_t <>= type, extends (pcm_t) :: pcm_nlo_t type(string_t) :: id logical :: combined_integration = .false. logical :: vis_fks_regions = .false. integer, dimension(:), allocatable :: nlo_type integer, dimension(:), allocatable :: nlo_type_core integer, dimension(:), allocatable :: component_type integer :: i_born = 0 integer :: i_real = 0 integer :: i_sub = 0 type(nlo_settings_t) :: settings type(region_data_t) :: region_data logical :: use_real_partition = .false. logical :: use_real_singular = .false. real(default) :: real_partition_scale = 0 class(real_partition_t), allocatable :: real_partition type(dalitz_plot_t) :: dalitz_plot type(quantum_numbers_t), dimension(:,:), allocatable :: qn_real, qn_born contains <> end type pcm_nlo_t @ %def pcm_nlo_t @ Initialize configuration data, using environment variables. <>= procedure :: init => pcm_nlo_init <>= module subroutine pcm_nlo_init (pcm, env, meta) class(pcm_nlo_t), intent(out) :: pcm type(process_metadata_t), intent(in) :: meta type(process_environment_t), intent(in) :: env end subroutine pcm_nlo_init <>= module subroutine pcm_nlo_init (pcm, env, meta) class(pcm_nlo_t), intent(out) :: pcm type(process_metadata_t), intent(in) :: meta type(process_environment_t), intent(in) :: env type(var_list_t), pointer :: var_list type(fks_template_t) :: fks_template pcm%id = meta%id pcm%has_pdfs = env%has_pdfs () var_list => env%get_var_list_ptr () call dispatch_fks_setup (fks_template, var_list) call pcm%settings%init (var_list, fks_template) pcm%combined_integration = & var_list%get_lval (var_str ('?combined_nlo_integration')) select case (char (var_list%get_sval (var_str ("$real_partition_mode")))) case ("default", "off") pcm%use_real_partition = .false. pcm%use_real_singular = .false. case ("all", "on", "singular") pcm%use_real_partition = .true. pcm%use_real_singular = .true. case ("finite") pcm%use_real_partition = .true. pcm%use_real_singular = .false. case default call msg_fatal ("The real partition mode can only be " // & "default, off, all, on, singular or finite.") end select pcm%real_partition_scale = & var_list%get_rval (var_str ("real_partition_scale")) pcm%vis_fks_regions = & var_list%get_lval (var_str ("?vis_fks_regions")) call pcm%set_blha_defaults & (env%has_polarized_beams (), env%get_var_list_ptr ()) pcm%os_data = env%get_os_data () end subroutine pcm_nlo_init @ %def pcm_nlo_init @ Init/rewrite NLO settings without the FKS template. <>= procedure :: init_nlo_settings => pcm_nlo_init_nlo_settings <>= module subroutine pcm_nlo_init_nlo_settings (pcm, var_list) class(pcm_nlo_t), intent(inout) :: pcm type(var_list_t), intent(in), target :: var_list end subroutine pcm_nlo_init_nlo_settings <>= module subroutine pcm_nlo_init_nlo_settings (pcm, var_list) class(pcm_nlo_t), intent(inout) :: pcm type(var_list_t), intent(in), target :: var_list call pcm%settings%init (var_list) end subroutine pcm_nlo_init_nlo_settings @ %def pcm_nlo_init_nlo_settings @ As appropriate for the NLO/FKS algorithm, the category defined by the process, is called [[nlo_type]]. We refine this by setting the component category [[component_type]] separately. The component types [[COMP_MISMATCH]], [[COMP_PDF]], [[COMP_SUB]] are set only if the algorithm uses combined integration. Otherwise, they are set to [[COMP_DEFAULT]]. The component type [[COMP_REAL]] is further distinguished between [[COMP_REAL_SING]] or [[COMP_REAL_FIN]], if the algorithm uses real partitions. The former acts as a reference component for the latter, and we always assume that it is the first real component. Each component is assigned its own core. Exceptions: the finite-real component gets the same core as the singular-real component. The mismatch component gets the same core as the subtraction component. TODO wk 2018: this convention for real components can be improved. Check whether all component types should be assigned, not just for combined integration. <>= procedure :: categorize_components => pcm_nlo_categorize_components <>= module subroutine pcm_nlo_categorize_components (pcm, config) class(pcm_nlo_t), intent(inout) :: pcm type(process_config_data_t), intent(in) :: config end subroutine pcm_nlo_categorize_components <>= module subroutine pcm_nlo_categorize_components (pcm, config) class(pcm_nlo_t), intent(inout) :: pcm type(process_config_data_t), intent(in) :: config type(process_component_def_t), pointer :: component_def integer :: i allocate (pcm%nlo_type (pcm%n_components), source = COMPONENT_UNDEFINED) allocate (pcm%component_type (pcm%n_components), source = COMP_DEFAULT) do i = 1, pcm%n_components component_def => config%process_def%get_component_def_ptr (i) pcm%nlo_type(i) = component_def%get_nlo_type () if (pcm%combined_integration) then select case (pcm%nlo_type(i)) case (BORN) pcm%i_born = i pcm%component_type(i) = COMP_MASTER case (NLO_REAL) pcm%component_type(i) = COMP_REAL case (NLO_VIRTUAL) pcm%component_type(i) = COMP_VIRT case (NLO_MISMATCH) pcm%component_type(i) = COMP_MISMATCH case (NLO_DGLAP) pcm%component_type(i) = COMP_PDF case (NLO_SUBTRACTION) pcm%component_type(i) = COMP_SUB pcm%i_sub = i end select else select case (pcm%nlo_type(i)) case (BORN) pcm%i_born = i pcm%component_type(i) = COMP_MASTER case (NLO_REAL) pcm%component_type(i) = COMP_REAL case (NLO_VIRTUAL) pcm%component_type(i) = COMP_VIRT case (NLO_MISMATCH) pcm%component_type(i) = COMP_MISMATCH case (NLO_SUBTRACTION) pcm%i_sub = i end select end if end do call refine_real_type ( & pack ([(i, i=1, pcm%n_components)], & pcm%component_type==COMP_REAL)) contains subroutine refine_real_type (i_real) integer, dimension(:), intent(in) :: i_real pcm%i_real = i_real(1) if (pcm%use_real_partition) then pcm%component_type (i_real(1)) = COMP_REAL_SING pcm%component_type (i_real(2:)) = COMP_REAL_FIN end if end subroutine refine_real_type end subroutine pcm_nlo_categorize_components @ %def pcm_nlo_categorize_components @ \subsubsection{Phase-space initial configuration} Setup for the NLO/PHS processes: two phase-space configurations, (1) Born/wood, (2) real correction/FKS. All components use either one of these two configurations. TODO wk 2018: The [[first_real_component]] identifier is really ugly. Nothing should rely on the ordering. <>= procedure :: init_phs_config => pcm_nlo_init_phs_config <>= module subroutine pcm_nlo_init_phs_config & (pcm, phs_entry, meta, env, phs_par, mapping_defs) class(pcm_nlo_t), intent(inout) :: pcm type(process_phs_config_t), & dimension(:), allocatable, intent(out) :: phs_entry type(process_metadata_t), intent(in) :: meta type(process_environment_t), intent(in) :: env type(mapping_defaults_t), intent(in) :: mapping_defs type(phs_parameters_t), intent(in) :: phs_par end subroutine pcm_nlo_init_phs_config <>= module subroutine pcm_nlo_init_phs_config & (pcm, phs_entry, meta, env, phs_par, mapping_defs) class(pcm_nlo_t), intent(inout) :: pcm type(process_phs_config_t), & dimension(:), allocatable, intent(out) :: phs_entry type(process_metadata_t), intent(in) :: meta type(process_environment_t), intent(in) :: env type(mapping_defaults_t), intent(in) :: mapping_defs type(phs_parameters_t), intent(in) :: phs_par integer :: i logical :: first_real_component allocate (phs_entry (2)) call dispatch_phs (phs_entry(1)%phs_config, & env%get_var_list_ptr (), & env%get_os_data (), & meta%id, & mapping_defs, phs_par, & var_str ("wood")) call dispatch_phs (phs_entry(2)%phs_config, & env%get_var_list_ptr (), & env%get_os_data (), & meta%id, & mapping_defs, phs_par, & var_str ("fks")) allocate (pcm%i_phs_config (pcm%n_components), source=0) first_real_component = .true. do i = 1, pcm%n_components select case (pcm%nlo_type(i)) case (BORN, NLO_VIRTUAL, NLO_SUBTRACTION) pcm%i_phs_config(i) = 1 case (NLO_REAL) if (pcm%use_real_partition) then if (pcm%use_real_singular) then if (first_real_component) then pcm%i_phs_config(i) = 2 first_real_component = .false. else pcm%i_phs_config(i) = 1 end if else pcm%i_phs_config(i) = 1 end if else pcm%i_phs_config(i) = 2 end if case (NLO_MISMATCH, NLO_DGLAP, GKS) pcm%i_phs_config(i) = 2 end select end do end subroutine pcm_nlo_init_phs_config @ %def pcm_nlo_init_phs_config @ \subsubsection{Core management} Allocate the core (matrix-element interface) objects that we will need for evaluation. Every component gets an associated core, except for the real-finite and mismatch components (if any). Those components are associated with their previous corresponding real-singular and subtraction cores, respectively. After cores are allocated, configure the region-data block that is maintained by the NLO process-component manager. <>= procedure :: allocate_cores => pcm_nlo_allocate_cores <>= module subroutine pcm_nlo_allocate_cores (pcm, config, core_entry) class(pcm_nlo_t), intent(inout) :: pcm type(process_config_data_t), intent(in) :: config type(core_entry_t), dimension(:), allocatable, intent(out) :: core_entry end subroutine pcm_nlo_allocate_cores <>= module subroutine pcm_nlo_allocate_cores (pcm, config, core_entry) class(pcm_nlo_t), intent(inout) :: pcm type(process_config_data_t), intent(in) :: config type(core_entry_t), dimension(:), allocatable, intent(out) :: core_entry type(process_component_def_t), pointer :: component_def integer :: i, i_core allocate (pcm%i_core (pcm%n_components), source = 0) pcm%n_cores = pcm%n_components & - count (pcm%component_type(:) == COMP_REAL_FIN) & - count (pcm%component_type(:) == COMP_MISMATCH) allocate (core_entry (pcm%n_cores)) allocate (pcm%nlo_type_core (pcm%n_cores), source = BORN) i_core = 0 do i = 1, pcm%n_components select case (pcm%component_type(i)) case default i_core = i_core + 1 pcm%i_core(i) = i_core pcm%nlo_type_core(i_core) = pcm%nlo_type(i) core_entry(i_core)%i_component = i component_def => config%process_def%get_component_def_ptr (i) core_entry(i_core)%core_def => component_def%get_core_def_ptr () select case (pcm%nlo_type(i)) case default core_entry(i)%active = component_def%can_be_integrated () case (NLO_REAL, NLO_SUBTRACTION) core_entry(i)%active = .true. end select case (COMP_REAL_FIN) pcm%i_core(i) = pcm%i_core(pcm%i_real) case (COMP_MISMATCH) pcm%i_core(i) = pcm%i_core(pcm%i_sub) end select end do end subroutine pcm_nlo_allocate_cores @ %def pcm_nlo_allocate_cores @ Extra code is required for certain core types (threshold) or if BLHA uses an external OLP for getting its matrix elements. OMega matrix elements, by definition, do not need extra code. NLO-virtual or subtraction matrix elements always need extra code. More precisely: for the Born and virtual matrix element, the extra code is accessed only if the component is active. The radiation (real) and the subtraction corrections (singular and finite), extra code is accessed in any case. The flavor state is taken from the [[region_data]] table in the [[pcm]] record. We use the Born and real flavor-state tables as appropriate. <>= procedure :: prepare_any_external_code => & pcm_nlo_prepare_any_external_code <>= module subroutine pcm_nlo_prepare_any_external_code & (pcm, core_entry, i_core, libname, model, var_list) class(pcm_nlo_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry integer, intent(in) :: i_core type(string_t), intent(in) :: libname type(model_data_t), intent(in), target :: model type(var_list_t), intent(in) :: var_list end subroutine pcm_nlo_prepare_any_external_code <>= module subroutine pcm_nlo_prepare_any_external_code & (pcm, core_entry, i_core, libname, model, var_list) class(pcm_nlo_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry integer, intent(in) :: i_core type(string_t), intent(in) :: libname type(model_data_t), intent(in), target :: model type(var_list_t), intent(in) :: var_list integer, dimension(:,:), allocatable :: flv_born, flv_real integer :: i call pcm%region_data%get_all_flv_states (flv_born, flv_real) if (core_entry%active) then associate (core => core_entry%core) if (core%needs_external_code ()) then select case (pcm%nlo_type (core_entry%i_component)) case default call core%data%set_flv_state (flv_born) case (NLO_REAL) call core%data%set_flv_state (flv_real) end select call core%prepare_external_code & (core%data%flv_state, & var_list, pcm%os_data, libname, model, i_core, .true.) end if call core%set_equivalent_flv_hel_indices () end associate end if end subroutine pcm_nlo_prepare_any_external_code @ %def pcm_nlo_prepare_any_external_code @ Allocate and configure the BLHA record for a specific core, assuming that the core type requires it. The configuration depends on the NLO type of the core. <>= procedure :: setup_blha => pcm_nlo_setup_blha <>= module subroutine pcm_nlo_setup_blha (pcm, core_entry) class(pcm_nlo_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry end subroutine pcm_nlo_setup_blha <>= module subroutine pcm_nlo_setup_blha (pcm, core_entry) class(pcm_nlo_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry allocate (core_entry%blha_config, source = pcm%blha_defaults) select case (pcm%nlo_type(core_entry%i_component)) case (BORN) call core_entry%blha_config%set_born () case (NLO_REAL) call core_entry%blha_config%set_real_trees () case (NLO_VIRTUAL) call core_entry%blha_config%set_loop () case (NLO_SUBTRACTION) call core_entry%blha_config%set_subtraction () call core_entry%blha_config%set_internal_color_correlations () case (NLO_DGLAP) call core_entry%blha_config%set_dglap () end select end subroutine pcm_nlo_setup_blha @ %def pcm_nlo_setup_blha @ After phase-space configuration data and core entries are available, we fill tables and compute the remaining NLO data that will steer the integration and subtraction algorithm. There are three parts: recognize a threshold-type process core (if it exists), prepare the region-data tables (always), and prepare for real partitioning (if requested). The real-component phase space acts as the source for resonance-history information, required for the region data. <>= procedure :: complete_setup => pcm_nlo_complete_setup <>= module subroutine pcm_nlo_complete_setup (pcm, core_entry, component, model) class(pcm_nlo_t), intent(inout) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry type(process_component_t), dimension(:), intent(inout) :: component type(model_t), intent(in), target :: model end subroutine pcm_nlo_complete_setup <>= module subroutine pcm_nlo_complete_setup (pcm, core_entry, component, model) class(pcm_nlo_t), intent(inout) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry type(process_component_t), dimension(:), intent(inout) :: component type(model_t), intent(in), target :: model integer :: alpha_power, alphas_power call pcm%handle_threshold_core (core_entry) call component(1)%config%get_coupling_powers (alpha_power, alphas_power) call pcm%setup_region_data (core_entry, & component(pcm%i_real)%phs_config, model, alpha_power, alphas_power) call pcm%setup_real_partition () end subroutine pcm_nlo_complete_setup @ %def pcm_nlo_complete_setup @ Apply the BLHA configuration to a core object, using the region data from [[pcm]] for determining the particle content. <>= procedure :: prepare_blha_core => pcm_nlo_prepare_blha_core <>= module subroutine pcm_nlo_prepare_blha_core (pcm, core_entry, model) class(pcm_nlo_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry class(model_data_t), intent(in), target :: model end subroutine pcm_nlo_prepare_blha_core <>= module subroutine pcm_nlo_prepare_blha_core (pcm, core_entry, model) class(pcm_nlo_t), intent(in) :: pcm type(core_entry_t), intent(inout) :: core_entry class(model_data_t), intent(in), target :: model integer :: n_in integer :: n_legs integer :: n_flv integer :: n_hel select type (core => core_entry%core) class is (prc_blha_t) associate (blha_config => core_entry%blha_config) n_in = core%data%n_in select case (pcm%nlo_type(core_entry%i_component)) case (NLO_REAL) n_legs = pcm%region_data%get_n_legs_real () n_flv = pcm%region_data%get_n_flv_real () case default n_legs = pcm%region_data%get_n_legs_born () n_flv = pcm%region_data%get_n_flv_born () end select n_hel = blha_config%get_n_hel (core%data%flv_state (1:n_in,1), model) call core%init_blha (blha_config, n_in, n_legs, n_flv, n_hel) call core%init_driver (pcm%os_data) end associate end select end subroutine pcm_nlo_prepare_blha_core @ %def pcm_nlo_prepare_blha_core @ Read the method settings from the variable list and store them in the BLHA master. This version: NLO flag set. <>= procedure :: set_blha_methods => pcm_nlo_set_blha_methods <>= module subroutine pcm_nlo_set_blha_methods (pcm, blha_master, var_list) class(pcm_nlo_t), intent(inout) :: pcm type(blha_master_t), intent(inout) :: blha_master type(var_list_t), intent(in) :: var_list end subroutine pcm_nlo_set_blha_methods <>= module subroutine pcm_nlo_set_blha_methods (pcm, blha_master, var_list) class(pcm_nlo_t), intent(inout) :: pcm type(blha_master_t), intent(inout) :: blha_master type(var_list_t), intent(in) :: var_list call blha_master%set_methods (.true., var_list) call pcm%blha_defaults%set_loop_method (blha_master) end subroutine pcm_nlo_set_blha_methods @ %def pcm_nlo_set_blha_methods @ Produce the LO and NLO flavor-state tables (as far as available), as appropriate for BLHA configuration. The NLO version copies the tables from the region data inside [[pcm]]. The core array is not needed. <>= procedure :: get_blha_flv_states => pcm_nlo_get_blha_flv_states <>= module subroutine pcm_nlo_get_blha_flv_states & (pcm, core_entry, flv_born, flv_real) class(pcm_nlo_t), intent(in) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry integer, dimension(:,:), allocatable, intent(out) :: flv_born integer, dimension(:,:), allocatable, intent(out) :: flv_real end subroutine pcm_nlo_get_blha_flv_states <>= module subroutine pcm_nlo_get_blha_flv_states & (pcm, core_entry, flv_born, flv_real) class(pcm_nlo_t), intent(in) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry integer, dimension(:,:), allocatable, intent(out) :: flv_born integer, dimension(:,:), allocatable, intent(out) :: flv_real call pcm%region_data%get_all_flv_states (flv_born, flv_real) end subroutine pcm_nlo_get_blha_flv_states @ %def pcm_nlo_get_blha_flv_states @ Allocate and configure the MCI (multi-channel integrator) records. The relation depends on the [[combined_integration]] setting. If we integrate components separately, each component gets its own record, except for the subtraction component. If we do the combination, there is one record for the master (Born) component and a second one for the real-finite component, if present. Each entry acquires some NLO-specific initialization. Generic configuration follows later. Second procedure: call the MCI dispatcher with NLO-setup arguments. <>= procedure :: setup_mci => pcm_nlo_setup_mci procedure :: call_dispatch_mci => pcm_nlo_call_dispatch_mci <>= module subroutine pcm_nlo_setup_mci (pcm, mci_entry) class(pcm_nlo_t), intent(inout) :: pcm type(process_mci_entry_t), & dimension(:), allocatable, intent(out) :: mci_entry end subroutine pcm_nlo_setup_mci module subroutine pcm_nlo_call_dispatch_mci (pcm, & dispatch_mci, var_list, process_id, mci_template) class(pcm_nlo_t), intent(inout) :: pcm procedure(dispatch_mci_proc) :: dispatch_mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id class(mci_t), allocatable, intent(out) :: mci_template end subroutine pcm_nlo_call_dispatch_mci <>= module subroutine pcm_nlo_setup_mci (pcm, mci_entry) class(pcm_nlo_t), intent(inout) :: pcm type(process_mci_entry_t), & dimension(:), allocatable, intent(out) :: mci_entry class(mci_t), allocatable :: mci_template integer :: i, i_mci if (pcm%combined_integration) then pcm%n_mci = 1 & + count (pcm%component_active(:) & & .and. pcm%component_type(:) == COMP_REAL_FIN) allocate (pcm%i_mci (pcm%n_components), source = 0) do i = 1, pcm%n_components if (pcm%component_active(i)) then select case (pcm%component_type(i)) case (COMP_MASTER) pcm%i_mci(i) = 1 case (COMP_REAL_FIN) pcm%i_mci(i) = 2 end select end if end do else pcm%n_mci = count (pcm%component_active(:) & & .and. pcm%nlo_type(:) /= NLO_SUBTRACTION) allocate (pcm%i_mci (pcm%n_components), source = 0) i_mci = 0 do i = 1, pcm%n_components if (pcm%component_active(i)) then select case (pcm%nlo_type(i)) case default i_mci = i_mci + 1 pcm%i_mci(i) = i_mci case (NLO_SUBTRACTION) end select end if end do end if allocate (mci_entry (pcm%n_mci)) mci_entry(:)%combined_integration = pcm%combined_integration if (pcm%use_real_partition) then do i = 1, pcm%n_components i_mci = pcm%i_mci(i) if (i_mci > 0) then select case (pcm%component_type(i)) case (COMP_REAL_FIN) mci_entry(i_mci)%real_partition_type = REAL_FINITE case default mci_entry(i_mci)%real_partition_type = REAL_SINGULAR end select end if end do end if end subroutine pcm_nlo_setup_mci module subroutine pcm_nlo_call_dispatch_mci (pcm, & dispatch_mci, var_list, process_id, mci_template) class(pcm_nlo_t), intent(inout) :: pcm procedure(dispatch_mci_proc) :: dispatch_mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id class(mci_t), allocatable, intent(out) :: mci_template call dispatch_mci (mci_template, var_list, process_id, is_nlo = .true.) end subroutine pcm_nlo_call_dispatch_mci @ %def pcm_nlo_setup_mci @ %def pcm_nlo_call_dispatch_mci @ Check for a threshold core and adjust the configuration accordingly, before singular region data are considered. <>= procedure :: handle_threshold_core => pcm_nlo_handle_threshold_core <>= module subroutine pcm_nlo_handle_threshold_core (pcm, core_entry) class(pcm_nlo_t), intent(inout) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry end subroutine pcm_nlo_handle_threshold_core <>= module subroutine pcm_nlo_handle_threshold_core (pcm, core_entry) class(pcm_nlo_t), intent(inout) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry integer :: i do i = 1, size (core_entry) select type (core => core_entry(i)%core_def) type is (threshold_def_t) pcm%settings%factorization_mode = FACTORIZATION_THRESHOLD return end select end do end subroutine pcm_nlo_handle_threshold_core @ %def pcm_nlo_handle_threshold_core @ Configure the singular-region tables based on the process data for the Born and Real (singular) cores, using also the appropriate FKS phase-space configuration object. In passing, we may create a table of resonance histories that are relevant for the singular-region configuration. TODO wk 2018: check whether [[phs_entry]] needs to be intent(inout). <>= procedure :: setup_region_data => pcm_nlo_setup_region_data <>= module subroutine pcm_nlo_setup_region_data & (pcm, core_entry, phs_config, model, alpha_power, alphas_power) class(pcm_nlo_t), intent(inout) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry class(phs_config_t), intent(inout) :: phs_config type(model_t), intent(in), target :: model integer, intent(in) :: alpha_power, alphas_power end subroutine pcm_nlo_setup_region_data <>= module subroutine pcm_nlo_setup_region_data & (pcm, core_entry, phs_config, model, alpha_power, alphas_power) class(pcm_nlo_t), intent(inout) :: pcm type(core_entry_t), dimension(:), intent(in) :: core_entry class(phs_config_t), intent(inout) :: phs_config type(model_t), intent(in), target :: model integer, intent(in) :: alpha_power, alphas_power type(process_constants_t) :: data_born, data_real integer, dimension (:,:), allocatable :: flavor_born, flavor_real type(resonance_history_t), dimension(:), allocatable :: resonance_histories type(var_list_t), pointer :: var_list logical :: success data_born = core_entry(pcm%i_core(pcm%i_born))%core%data data_real = core_entry(pcm%i_core(pcm%i_real))%core%data call data_born%get_flv_state (flavor_born) call data_real%get_flv_state (flavor_real) call pcm%region_data%init & (data_born%n_in, model, flavor_born, flavor_real, & pcm%settings%nlo_correction_type, alpha_power, alphas_power) associate (template => pcm%settings%fks_template) if (template%mapping_type == FKS_RESONANCES) then select type (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 (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 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 () call pcm%region_data%write_to_file & (pcm%id, pcm%vis_fks_regions, pcm%os_data) if (debug_active (D_SUBTRACTION)) & call pcm%region_data%check_consistency (.true.) end subroutine pcm_nlo_setup_region_data @ %def pcm_nlo_setup_region_data @ After region data are set up, we allocate and configure the [[real_partition]] objects, if requested. Gfortran 7/8/9 bug, has to remain in the main module: <>= procedure :: setup_real_partition => pcm_nlo_setup_real_partition <>= subroutine pcm_nlo_setup_real_partition (pcm) class(pcm_nlo_t), intent(inout) :: pcm if (pcm%use_real_partition) then 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 = pcm%real_partition_scale end select end if end if end subroutine pcm_nlo_setup_real_partition @ %def pcm_nlo_setup_real_partition @ Initialize a single component. We require all process-configuration blocks, and specific templates for the phase-space and integrator configuration. We also provide the current component index [[i]] and the [[active]] flag. For a subtraction component, the [[active]] flag is overridden. In the nlo mode, the component types have been determined before. TODO wk 2018: the component type need not be stored in the component; we may remove this when everything is controlled by [[pcm]]. <>= procedure :: init_component => pcm_nlo_init_component <>= module subroutine pcm_nlo_init_component (pcm, component, i, active, & phs_config, env, meta, config) class(pcm_nlo_t), intent(in) :: pcm type(process_component_t), intent(out) :: component integer, intent(in) :: i logical, intent(in) :: active class(phs_config_t), allocatable, intent(in) :: phs_config type(process_environment_t), intent(in) :: env type(process_metadata_t), intent(in) :: meta type(process_config_data_t), intent(in) :: config end subroutine pcm_nlo_init_component <>= module subroutine pcm_nlo_init_component (pcm, component, i, active, & phs_config, env, meta, config) class(pcm_nlo_t), intent(in) :: pcm type(process_component_t), intent(out) :: component integer, intent(in) :: i logical, intent(in) :: active class(phs_config_t), allocatable, intent(in) :: phs_config type(process_environment_t), intent(in) :: env type(process_metadata_t), intent(in) :: meta type(process_config_data_t), intent(in) :: config logical :: activate select case (pcm%nlo_type(i)) case default; activate = active case (NLO_SUBTRACTION); activate = .false. end select call component%init (i, & env, meta, config, & activate, & phs_config) component%component_type = pcm%component_type(i) end subroutine pcm_nlo_init_component @ %def pcm_nlo_init_component @ Override the base method: record the active components in the PCM object, and report inactive components (except for the subtraction component). <>= procedure :: record_inactive_components => pcm_nlo_record_inactive_components <>= module subroutine pcm_nlo_record_inactive_components (pcm, component, meta) class(pcm_nlo_t), intent(inout) :: pcm type(process_component_t), dimension(:), intent(in) :: component type(process_metadata_t), intent(inout) :: meta end subroutine pcm_nlo_record_inactive_components <>= module subroutine pcm_nlo_record_inactive_components (pcm, component, meta) class(pcm_nlo_t), intent(inout) :: pcm type(process_component_t), dimension(:), intent(in) :: component type(process_metadata_t), intent(inout) :: meta integer :: i pcm%component_active = component%active do i = 1, pcm%n_components select case (pcm%nlo_type(i)) case (NLO_SUBTRACTION) case default if (.not. component(i)%active) call meta%deactivate_component (i) end select end do end subroutine pcm_nlo_record_inactive_components @ %def pcm_nlo_record_inactive_components @ <>= procedure :: core_is_radiation => pcm_nlo_core_is_radiation <>= module function pcm_nlo_core_is_radiation (pcm, i_core) result (is_rad) logical :: is_rad class(pcm_nlo_t), intent(in) :: pcm integer, intent(in) :: i_core end function pcm_nlo_core_is_radiation <>= module function pcm_nlo_core_is_radiation (pcm, i_core) result (is_rad) logical :: is_rad class(pcm_nlo_t), intent(in) :: pcm integer, intent(in) :: i_core is_rad = pcm%nlo_type(i_core) == NLO_REAL ! .and. .not. pcm%cm%sub(i_core) end function pcm_nlo_core_is_radiation @ %def pcm_nlo_core_is_radiation @ <>= procedure :: get_n_flv_born => pcm_nlo_get_n_flv_born <>= module function pcm_nlo_get_n_flv_born (pcm_nlo) result (n_flv) integer :: n_flv class(pcm_nlo_t), intent(in) :: pcm_nlo end function pcm_nlo_get_n_flv_born <>= module 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 @ <>= procedure :: get_n_flv_real => pcm_nlo_get_n_flv_real <>= module function pcm_nlo_get_n_flv_real (pcm_nlo) result (n_flv) integer :: n_flv class(pcm_nlo_t), intent(in) :: pcm_nlo end function pcm_nlo_get_n_flv_real <>= module 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 @ <>= procedure :: get_n_alr => pcm_nlo_get_n_alr <>= module function pcm_nlo_get_n_alr (pcm) result (n_alr) integer :: n_alr class(pcm_nlo_t), intent(in) :: pcm end function pcm_nlo_get_n_alr <>= module 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 @ <>= procedure :: get_flv_states => pcm_nlo_get_flv_states <>= module 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 end function pcm_nlo_get_flv_states <>= module 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 @ <>= procedure :: get_qn => pcm_nlo_get_qn <>= module 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 end function pcm_nlo_get_qn <>= module 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. <>= procedure :: has_massive_emitter => pcm_nlo_has_massive_emitter <>= module function pcm_nlo_has_massive_emitter (pcm) result (val) logical :: val class(pcm_nlo_t), intent(in) :: pcm end function pcm_nlo_has_massive_emitter <>= module 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. <>= procedure :: get_mass_info => pcm_nlo_get_mass_info <>= module 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 end function pcm_nlo_get_mass_info <>= module 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 @ Gfortran 7/8/9 bug, has to remain in the main module: <>= procedure :: allocate_workspace => pcm_nlo_allocate_workspace <>= subroutine pcm_nlo_allocate_workspace (pcm, work) class(pcm_nlo_t), intent(in) :: pcm class(pcm_workspace_t), intent(inout), allocatable :: work allocate (pcm_nlo_workspace_t :: work) end subroutine pcm_nlo_allocate_workspace @ %def pcm_nlo_allocate_workspace @ <>= procedure :: init_qn => pcm_nlo_init_qn <>= module subroutine pcm_nlo_init_qn (pcm, model) class(pcm_nlo_t), intent(inout) :: pcm class(model_data_t), intent(in) :: model end subroutine pcm_nlo_init_qn <>= module 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 @ Gfortran 7/8/9 bug, has to remain in the main module: <>= procedure :: allocate_ps_matching => pcm_nlo_allocate_ps_matching <>= 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 @ <>= procedure :: activate_dalitz_plot => pcm_nlo_activate_dalitz_plot <>= module subroutine pcm_nlo_activate_dalitz_plot (pcm, filename) class(pcm_nlo_t), intent(inout) :: pcm type(string_t), intent(in) :: filename end subroutine pcm_nlo_activate_dalitz_plot <>= module 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 @ <>= procedure :: register_dalitz_plot => pcm_nlo_register_dalitz_plot <>= module 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 end subroutine pcm_nlo_register_dalitz_plot <>= module 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 @ <>= procedure :: setup_phs_generator => pcm_nlo_setup_phs_generator <>= module subroutine pcm_nlo_setup_phs_generator (pcm, pcm_work, generator, & sqrts, mode, singular_jacobian) class(pcm_nlo_t), intent(in) :: pcm type(phs_fks_generator_t), intent(inout) :: generator type(pcm_nlo_workspace_t), intent(in), target :: pcm_work real(default), intent(in) :: sqrts integer, intent(in), optional:: mode logical, intent(in), optional :: singular_jacobian end subroutine pcm_nlo_setup_phs_generator <>= module subroutine pcm_nlo_setup_phs_generator (pcm, pcm_work, generator, & sqrts, mode, singular_jacobian) class(pcm_nlo_t), intent(in) :: pcm type(phs_fks_generator_t), intent(inout) :: generator type(pcm_nlo_workspace_t), intent(in), target :: pcm_work 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_work%isr_kinematics, & pcm_work%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 call generator%set_xi_and_y_bounds (pcm%settings%fks_template%xi_min, & pcm%settings%fks_template%y_max) end subroutine pcm_nlo_setup_phs_generator @ %def pcm_nlo_setup_phs_generator @ <>= procedure :: final => pcm_nlo_final <>= module subroutine pcm_nlo_final (pcm) class(pcm_nlo_t), intent(inout) :: pcm end subroutine pcm_nlo_final <>= module 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 @ <>= procedure :: is_nlo => pcm_nlo_is_nlo <>= module function pcm_nlo_is_nlo (pcm) result (is_nlo) logical :: is_nlo class(pcm_nlo_t), intent(in) :: pcm end function pcm_nlo_is_nlo <>= module 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. <>= public :: pcm_nlo_workspace_t <>= type, extends (pcm_workspace_t) :: pcm_nlo_workspace_t 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 <> end type pcm_nlo_workspace_t @ %def pcm_nlo_workspace_t @ <>= procedure :: set_radiation_event => pcm_nlo_workspace_set_radiation_event procedure :: set_subtraction_event => pcm_nlo_workspace_set_subtraction_event <>= module subroutine pcm_nlo_workspace_set_radiation_event (pcm_work) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work end subroutine pcm_nlo_workspace_set_radiation_event module subroutine pcm_nlo_workspace_set_subtraction_event (pcm_work) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work end subroutine pcm_nlo_workspace_set_subtraction_event <>= module subroutine pcm_nlo_workspace_set_radiation_event (pcm_work) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work pcm_work%real_sub%radiation_event = .true. pcm_work%real_sub%subtraction_event = .false. end subroutine pcm_nlo_workspace_set_radiation_event module subroutine pcm_nlo_workspace_set_subtraction_event (pcm_work) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work pcm_work%real_sub%radiation_event = .false. pcm_work%real_sub%subtraction_event = .true. end subroutine pcm_nlo_workspace_set_subtraction_event @ %def pcm_nlo_workspace_set_radiation_event @ %def pcm_nlo_workspace_set_subtraction_event <>= procedure :: disable_subtraction => pcm_nlo_workspace_disable_subtraction <>= module subroutine pcm_nlo_workspace_disable_subtraction (pcm_work) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work end subroutine pcm_nlo_workspace_disable_subtraction <>= module subroutine pcm_nlo_workspace_disable_subtraction (pcm_work) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work pcm_work%real_sub%subtraction_deactivated = .true. end subroutine pcm_nlo_workspace_disable_subtraction @ %def pcm_nlo_workspace_disable_subtraction @ <>= procedure :: init_config => pcm_nlo_workspace_init_config <>= module subroutine pcm_nlo_workspace_init_config (pcm_work, pcm, & active_components, nlo_types, energy, i_real_fin, model) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm logical, intent(in), dimension(:) :: active_components integer, intent(in), dimension(:) :: nlo_types real(default), intent(in), dimension(:) :: energy integer, intent(in) :: i_real_fin class(model_data_t), intent(in) :: model end subroutine pcm_nlo_workspace_init_config <>= module subroutine pcm_nlo_workspace_init_config (pcm_work, pcm, & active_components, nlo_types, energy, i_real_fin, model) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm logical, intent(in), dimension(:) :: active_components integer, intent(in), dimension(:) :: nlo_types real(default), intent(in), dimension(:) :: energy integer, intent(in) :: i_real_fin class(model_data_t), intent(in) :: model integer :: i_component if (debug_on) call msg_debug (D_PROCESS_INTEGRATION, & "pcm_nlo_workspace_init_config") call pcm_work%init_real_and_isr_kinematics (pcm, energy) select type (pcm) 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_work%setup_real_component (pcm, & pcm%settings%fks_template%subtraction_disabled) end if case (NLO_VIRTUAL) call pcm_work%init_virtual (pcm, model) case (NLO_MISMATCH) call pcm_work%init_soft_mismatch (pcm) case (NLO_DGLAP) call pcm_work%init_dglap_remnant (pcm) end select end if end do end select end subroutine pcm_nlo_workspace_init_config @ %def pcm_nlo_workspace_init_config @ <>= procedure :: setup_real_component => pcm_nlo_workspace_setup_real_component <>= module subroutine pcm_nlo_workspace_setup_real_component (pcm_work, pcm, & subtraction_disabled) class(pcm_nlo_workspace_t), intent(inout), target :: pcm_work class(pcm_t), intent(in) :: pcm logical, intent(in) :: subtraction_disabled end subroutine pcm_nlo_workspace_setup_real_component <>= module subroutine pcm_nlo_workspace_setup_real_component (pcm_work, pcm, & subtraction_disabled) class(pcm_nlo_workspace_t), intent(inout), target :: pcm_work class(pcm_t), intent(in) :: pcm logical, intent(in) :: subtraction_disabled select type (pcm) type is (pcm_nlo_t) call pcm_work%init_real_subtraction (pcm) if (subtraction_disabled) call pcm_work%disable_subtraction () end select end subroutine pcm_nlo_workspace_setup_real_component @ %def pcm_nlo_workspace_setup_real_component @ <>= procedure :: init_real_and_isr_kinematics => & pcm_nlo_workspace_init_real_and_isr_kinematics <>= module subroutine pcm_nlo_workspace_init_real_and_isr_kinematics & (pcm_work, pcm, energy) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm real(default), dimension(:), intent(in) :: energy end subroutine pcm_nlo_workspace_init_real_and_isr_kinematics <>= module subroutine pcm_nlo_workspace_init_real_and_isr_kinematics & (pcm_work, pcm, energy) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm real(default), dimension(:), intent(in) :: energy integer :: n_contr allocate (pcm_work%real_kinematics) allocate (pcm_work%isr_kinematics) select type (pcm) type is (pcm_nlo_t) associate (region_data => pcm%region_data) if (allocated (region_data%alr_contributors)) then n_contr = size (region_data%alr_contributors) else if (pcm%settings%factorization_mode == FACTORIZATION_THRESHOLD) then n_contr = 2 else n_contr = 1 end if call pcm_work%real_kinematics%init & (region_data%n_legs_real, region_data%n_phs, & region_data%n_regions, n_contr) if (pcm%settings%factorization_mode == FACTORIZATION_THRESHOLD) & call pcm_work%real_kinematics%init_onshell & (region_data%n_legs_real, region_data%n_phs) pcm_work%isr_kinematics%n_in = region_data%n_in end associate end select pcm_work%isr_kinematics%beam_energy = energy end subroutine pcm_nlo_workspace_init_real_and_isr_kinematics @ %def pcm_nlo_workspace_init_real_and_isr_kinematics @ <>= procedure :: set_real_and_isr_kinematics => & pcm_nlo_workspace_set_real_and_isr_kinematics <>= module subroutine pcm_nlo_workspace_set_real_and_isr_kinematics & (pcm_work, phs_identifiers, sqrts) class(pcm_nlo_workspace_t), intent(inout), target :: pcm_work type(phs_identifier_t), intent(in), dimension(:) :: phs_identifiers real(default), intent(in) :: sqrts end subroutine pcm_nlo_workspace_set_real_and_isr_kinematics <>= module subroutine pcm_nlo_workspace_set_real_and_isr_kinematics & (pcm_work, phs_identifiers, sqrts) class(pcm_nlo_workspace_t), intent(inout), target :: pcm_work type(phs_identifier_t), intent(in), dimension(:) :: phs_identifiers real(default), intent(in) :: sqrts call pcm_work%real_sub%set_real_kinematics & (pcm_work%real_kinematics) call pcm_work%real_sub%set_isr_kinematics & (pcm_work%isr_kinematics) end subroutine pcm_nlo_workspace_set_real_and_isr_kinematics @ %def pcm_nlo_workspace_set_real_and_isr_kinematics @ <>= procedure :: init_real_subtraction => pcm_nlo_workspace_init_real_subtraction <>= module subroutine pcm_nlo_workspace_init_real_subtraction (pcm_work, pcm) class(pcm_nlo_workspace_t), intent(inout), target :: pcm_work class(pcm_t), intent(in) :: pcm end subroutine pcm_nlo_workspace_init_real_subtraction <>= module subroutine pcm_nlo_workspace_init_real_subtraction (pcm_work, pcm) class(pcm_nlo_workspace_t), intent(inout), target :: pcm_work class(pcm_t), intent(in) :: pcm select type (pcm) type is (pcm_nlo_t) associate (region_data => pcm%region_data) call pcm_work%real_sub%init (region_data, pcm%settings) if (allocated (pcm%settings%selected_alr)) then associate (selected_alr => pcm%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_work%real_sub%selected_alr & (size (selected_alr))) pcm_work%real_sub%selected_alr = selected_alr end if end associate end if end associate end select end subroutine pcm_nlo_workspace_init_real_subtraction @ %def pcm_nlo_workspace_init_real_subtraction @ <>= procedure :: set_momenta_and_scales_virtual => & pcm_nlo_workspace_set_momenta_and_scales_virtual <>= module subroutine pcm_nlo_workspace_set_momenta_and_scales_virtual & (pcm_work, p, ren_scale, fac_scale, es_scale) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work type(vector4_t), intent(in), dimension(:) :: p real(default), allocatable, intent(in) :: ren_scale real(default), intent(in) :: fac_scale real(default), allocatable, intent(in) :: es_scale end subroutine pcm_nlo_workspace_set_momenta_and_scales_virtual <>= module subroutine pcm_nlo_workspace_set_momenta_and_scales_virtual & (pcm_work, p, ren_scale, fac_scale, es_scale) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work type(vector4_t), intent(in), dimension(:) :: p real(default), allocatable, intent(in) :: ren_scale real(default), intent(in) :: fac_scale real(default), allocatable, intent(in) :: es_scale associate (virtual => pcm_work%virtual) call virtual%set_ren_scale (ren_scale) call virtual%set_fac_scale (p, fac_scale) call virtual%set_ellis_sexton_scale (es_scale) end associate end subroutine pcm_nlo_workspace_set_momenta_and_scales_virtual @ %def pcm_nlo_workspace_set_momenta_and_scales_virtual @ <>= procedure :: set_fac_scale => pcm_nlo_workspace_set_fac_scale <>= module subroutine pcm_nlo_workspace_set_fac_scale (pcm_work, fac_scale) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work real(default), intent(in) :: fac_scale end subroutine pcm_nlo_workspace_set_fac_scale <>= module subroutine pcm_nlo_workspace_set_fac_scale (pcm_work, fac_scale) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work real(default), intent(in) :: fac_scale pcm_work%isr_kinematics%fac_scale = fac_scale end subroutine pcm_nlo_workspace_set_fac_scale @ %def pcm_nlo_workspace_set_fac_scale @ <>= procedure :: set_momenta => pcm_nlo_workspace_set_momenta <>= module subroutine pcm_nlo_workspace_set_momenta (pcm_work, & p_born, p_real, i_phs, cms) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work type(vector4_t), dimension(:), intent(in) :: p_born, p_real integer, intent(in) :: i_phs logical, intent(in), optional :: cms end subroutine pcm_nlo_workspace_set_momenta <>= module subroutine pcm_nlo_workspace_set_momenta (pcm_work, & p_born, p_real, i_phs, cms) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work 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_work%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_born kinematics%p_real_cms%phs_point(i_phs) = 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_born kinematics%p_real_lab%phs_point(i_phs) = p_real end if end associate end subroutine pcm_nlo_workspace_set_momenta @ %def pcm_nlo_workspace_set_momenta @ <>= procedure :: get_momenta => pcm_nlo_workspace_get_momenta <>= module function pcm_nlo_workspace_get_momenta (pcm_work, pcm, & i_phs, born_phsp, cms) result (p) type(vector4_t), dimension(:), allocatable :: p class(pcm_nlo_workspace_t), intent(in) :: pcm_work class(pcm_t), intent(in) :: pcm integer, intent(in) :: i_phs logical, intent(in) :: born_phsp logical, intent(in), optional :: cms end function pcm_nlo_workspace_get_momenta <>= module function pcm_nlo_workspace_get_momenta (pcm_work, pcm, & i_phs, born_phsp, cms) result (p) type(vector4_t), dimension(:), allocatable :: p class(pcm_nlo_workspace_t), intent(in) :: pcm_work class(pcm_t), intent(in) :: pcm 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 (pcm) type is (pcm_nlo_t) if (born_phsp) then if (yorn) then p = pcm_work%real_kinematics%p_born_cms%phs_point(1) else p = pcm_work%real_kinematics%p_born_lab%phs_point(1) end if else if (yorn) then p = pcm_work%real_kinematics%p_real_cms%phs_point(i_phs) else p = pcm_work%real_kinematics%p_real_lab%phs_point(i_phs) end if end if end select end function pcm_nlo_workspace_get_momenta @ %def pcm_nlo_workspace_get_momenta @ <>= procedure :: get_xi_max => pcm_nlo_workspace_get_xi_max <>= module function pcm_nlo_workspace_get_xi_max (pcm_work, alr) result (xi_max) real(default) :: xi_max class(pcm_nlo_workspace_t), intent(in) :: pcm_work integer, intent(in) :: alr end function pcm_nlo_workspace_get_xi_max <>= module function pcm_nlo_workspace_get_xi_max (pcm_work, alr) result (xi_max) real(default) :: xi_max class(pcm_nlo_workspace_t), intent(in) :: pcm_work integer, intent(in) :: alr integer :: i_phs i_phs = pcm_work%real_kinematics%alr_to_i_phs (alr) xi_max = pcm_work%real_kinematics%xi_max (i_phs) end function pcm_nlo_workspace_get_xi_max @ %def pcm_nlo_workspace_get_xi_max @ <>= procedure :: set_x_rad => pcm_nlo_workspace_set_x_rad <>= module subroutine pcm_nlo_workspace_set_x_rad (pcm_work, x_tot) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work real(default), intent(in), dimension(:) :: x_tot end subroutine pcm_nlo_workspace_set_x_rad <>= module subroutine pcm_nlo_workspace_set_x_rad (pcm_work, x_tot) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work real(default), intent(in), dimension(:) :: x_tot integer :: n_par n_par = size (x_tot) if (n_par < 3) then pcm_work%real_kinematics%x_rad = zero else pcm_work%real_kinematics%x_rad = x_tot (n_par - 2 : n_par) end if end subroutine pcm_nlo_workspace_set_x_rad @ %def pcm_nlo_workspace_set_x_rad @ <>= procedure :: init_virtual => pcm_nlo_workspace_init_virtual <>= module subroutine pcm_nlo_workspace_init_virtual (pcm_work, pcm, model) class(pcm_nlo_workspace_t), intent(inout), target :: pcm_work class(pcm_t), intent(in) :: pcm class(model_data_t), intent(in) :: model end subroutine pcm_nlo_workspace_init_virtual <>= module subroutine pcm_nlo_workspace_init_virtual (pcm_work, pcm, model) class(pcm_nlo_workspace_t), intent(inout), target :: pcm_work class(pcm_t), intent(in) :: pcm class(model_data_t), intent(in) :: model select type (pcm) type is (pcm_nlo_t) associate (region_data => pcm%region_data) call pcm_work%virtual%init (region_data%get_flv_states_born (), & region_data%n_in, pcm%settings, model, pcm%has_pdfs) end associate end select end subroutine pcm_nlo_workspace_init_virtual @ %def pcm_nlo_workspace_init_virtual @ <>= procedure :: disable_virtual_subtraction => & pcm_nlo_workspace_disable_virtual_subtraction <>= module subroutine pcm_nlo_workspace_disable_virtual_subtraction (pcm_work) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work end subroutine pcm_nlo_workspace_disable_virtual_subtraction <>= module subroutine pcm_nlo_workspace_disable_virtual_subtraction (pcm_work) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work end subroutine pcm_nlo_workspace_disable_virtual_subtraction @ %def pcm_nlo_workspace_disable_virtual_subtraction @ <>= procedure :: compute_sqme_virt => pcm_nlo_workspace_compute_sqme_virt <>= module subroutine pcm_nlo_workspace_compute_sqme_virt (pcm_work, pcm, p, & alpha_coupling, separate_uborns, sqme_virt) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm type(vector4_t), intent(in), dimension(:) :: p real(default), dimension(2), intent(in) :: alpha_coupling logical, intent(in) :: separate_uborns real(default), dimension(:), allocatable, intent(inout) :: sqme_virt end subroutine pcm_nlo_workspace_compute_sqme_virt <>= module subroutine pcm_nlo_workspace_compute_sqme_virt (pcm_work, pcm, p, & alpha_coupling, separate_uborns, sqme_virt) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm type(vector4_t), intent(in), dimension(:) :: p real(default), dimension(2), intent(in) :: alpha_coupling logical, intent(in) :: separate_uborns real(default), dimension(:), allocatable, intent(inout) :: sqme_virt type(vector4_t), dimension(:), allocatable :: pp associate (virtual => pcm_work%virtual) allocate (pp (size (p))) if (virtual%settings%factorization_mode == FACTORIZATION_THRESHOLD) then pp = pcm_work%real_kinematics%p_born_onshell%get_momenta (1) else pp = p end if select type (pcm) type is (pcm_nlo_t) if (separate_uborns) then allocate (sqme_virt (pcm%get_n_flv_born ())) else allocate (sqme_virt (1)) end if sqme_virt = zero call virtual%evaluate (pcm%region_data, & alpha_coupling, pp, separate_uborns, sqme_virt) end select end associate end subroutine pcm_nlo_workspace_compute_sqme_virt @ %def pcm_nlo_workspace_compute_sqme_virt @ <>= procedure :: compute_sqme_mismatch => pcm_nlo_workspace_compute_sqme_mismatch <>= module subroutine pcm_nlo_workspace_compute_sqme_mismatch (pcm_work, pcm, & alpha_s, separate_uborns, sqme_mism) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm real(default), intent(in) :: alpha_s logical, intent(in) :: separate_uborns real(default), dimension(:), allocatable, intent(inout) :: sqme_mism end subroutine pcm_nlo_workspace_compute_sqme_mismatch <>= module subroutine pcm_nlo_workspace_compute_sqme_mismatch (pcm_work, pcm, & alpha_s, separate_uborns, sqme_mism) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm real(default), intent(in) :: alpha_s logical, intent(in) :: separate_uborns real(default), dimension(:), allocatable, intent(inout) :: sqme_mism select type (pcm) type is (pcm_nlo_t) if (separate_uborns) then allocate (sqme_mism (pcm%get_n_flv_born ())) else allocate (sqme_mism (1)) end if sqme_mism = zero sqme_mism = pcm_work%soft_mismatch%evaluate (alpha_s) end select end subroutine pcm_nlo_workspace_compute_sqme_mismatch @ %def pcm_nlo_workspace_compute_sqme_mismatch @ <>= procedure :: compute_sqme_dglap_remnant => & pcm_nlo_workspace_compute_sqme_dglap_remnant <>= module subroutine pcm_nlo_workspace_compute_sqme_dglap_remnant (pcm_work, & pcm, alpha_coupling, separate_uborns, sqme_dglap) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm real(default), dimension(2), intent(in) :: alpha_coupling logical, intent(in) :: separate_uborns real(default), dimension(:), allocatable, intent(inout) :: sqme_dglap end subroutine pcm_nlo_workspace_compute_sqme_dglap_remnant <>= module subroutine pcm_nlo_workspace_compute_sqme_dglap_remnant (pcm_work, & pcm, alpha_coupling, separate_uborns, sqme_dglap) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm real(default), dimension(2), intent(in) :: alpha_coupling logical, intent(in) :: separate_uborns real(default), dimension(:), allocatable, intent(inout) :: sqme_dglap select type (pcm) type is (pcm_nlo_t) if (separate_uborns) then allocate (sqme_dglap (pcm%get_n_flv_born ())) else allocate (sqme_dglap (1)) end if end select sqme_dglap = zero call pcm_work%dglap_remnant%evaluate (alpha_coupling, & separate_uborns, sqme_dglap) end subroutine pcm_nlo_workspace_compute_sqme_dglap_remnant @ %def pcm_nlo_workspace_compute_sqme_dglap_remnant @ <>= procedure :: set_fixed_order_event_mode => & pcm_nlo_workspace_set_fixed_order_event_mode <>= module subroutine pcm_nlo_workspace_set_fixed_order_event_mode (pcm_work) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work end subroutine pcm_nlo_workspace_set_fixed_order_event_mode <>= module subroutine pcm_nlo_workspace_set_fixed_order_event_mode (pcm_work) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work pcm_work%real_sub%purpose = FIXED_ORDER_EVENTS end subroutine pcm_nlo_workspace_set_fixed_order_event_mode @ %def pcm_nlo_workspace_set_fixed_order_event_mode @ <>= procedure :: init_soft_mismatch => pcm_nlo_workspace_init_soft_mismatch <>= module subroutine pcm_nlo_workspace_init_soft_mismatch (pcm_work, pcm) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm end subroutine pcm_nlo_workspace_init_soft_mismatch <>= module subroutine pcm_nlo_workspace_init_soft_mismatch (pcm_work, pcm) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm select type (pcm) type is (pcm_nlo_t) call pcm_work%soft_mismatch%init (pcm%region_data, & pcm_work%real_kinematics, pcm%settings%factorization_mode) end select end subroutine pcm_nlo_workspace_init_soft_mismatch @ %def pcm_nlo_workspace_init_soft_mismatch @ <>= procedure :: init_dglap_remnant => pcm_nlo_workspace_init_dglap_remnant <>= module subroutine pcm_nlo_workspace_init_dglap_remnant (pcm_work, pcm) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm end subroutine pcm_nlo_workspace_init_dglap_remnant <>= module subroutine pcm_nlo_workspace_init_dglap_remnant (pcm_work, pcm) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work class(pcm_t), intent(in) :: pcm select type (pcm) type is (pcm_nlo_t) call pcm_work%dglap_remnant%init ( & pcm%settings, & pcm%region_data, & pcm_work%isr_kinematics) end select end subroutine pcm_nlo_workspace_init_dglap_remnant @ %def pcm_nlo_workspace_init_dglap_remnant @ <>= procedure :: is_fixed_order_nlo_events & => pcm_nlo_workspace_is_fixed_order_nlo_events <>= module function pcm_nlo_workspace_is_fixed_order_nlo_events & (pcm_work) result (is_fnlo) logical :: is_fnlo class(pcm_nlo_workspace_t), intent(in) :: pcm_work end function pcm_nlo_workspace_is_fixed_order_nlo_events <>= module function pcm_nlo_workspace_is_fixed_order_nlo_events & (pcm_work) result (is_fnlo) logical :: is_fnlo class(pcm_nlo_workspace_t), intent(in) :: pcm_work is_fnlo = pcm_work%real_sub%purpose == FIXED_ORDER_EVENTS end function pcm_nlo_workspace_is_fixed_order_nlo_events @ %def pcm_nlo_workspace_is_fixed_order_nlo_events @ <>= procedure :: final => pcm_nlo_workspace_final <>= module subroutine pcm_nlo_workspace_final (pcm_work) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work end subroutine pcm_nlo_workspace_final <>= module subroutine pcm_nlo_workspace_final (pcm_work) class(pcm_nlo_workspace_t), intent(inout) :: pcm_work call pcm_work%real_sub%final () call pcm_work%virtual%final () call pcm_work%soft_mismatch%final () call pcm_work%dglap_remnant%final () if (associated (pcm_work%real_kinematics)) then call pcm_work%real_kinematics%final () nullify (pcm_work%real_kinematics) end if if (associated (pcm_work%isr_kinematics)) then nullify (pcm_work%isr_kinematics) end if end subroutine pcm_nlo_workspace_final @ %def pcm_nlo_workspace_final @ <>= procedure :: is_nlo => pcm_nlo_workspace_is_nlo <>= module function pcm_nlo_workspace_is_nlo (pcm_work) result (is_nlo) logical :: is_nlo class(pcm_nlo_workspace_t), intent(inout) :: pcm_work end function pcm_nlo_workspace_is_nlo <>= module function pcm_nlo_workspace_is_nlo (pcm_work) result (is_nlo) logical :: is_nlo class(pcm_nlo_workspace_t), intent(inout) :: pcm_work is_nlo = .true. end function pcm_nlo_workspace_is_nlo @ %def pcm_nlo_workspace_is_nlo @ This routine modifies the kinematic factors applied to the real matrix element for use with POWHEG matching. We need to divide the real matrix element by [[xi_max]] to cancel a factor of [[xi_max]] applied in [[apply_kinematic_factors_radiation]]. It comes from the fact that we sample $\tilde\xi \in [0,1]$ when integrating but $\xi \in [p_T^2,\xi_\text{max}]$ for POWHEG matching. Thus, we are taking into account that $d\xi = d\tilde\xi \frac{\xi}{\tilde\xi} = d\tilde\xi \xi_\text{max}$. Additionally, we need to cancel the Jacobian from the random number mapping. We only want the physical part of the Jacobian in our Sudakov splitting function. Furthermore, the real matrix element lacks its flux factor $\frac{1}{2 \hat s_{\mathcal{R}}}$ and the real Jacobian lacks a factor of $\frac{1}{1-\xi}$. Together, this is a factor of $\frac{1}{2 \hat s_{\mathcal{B}}}$, i.e. the same as the flux factor of the Born matrix element. We do not correct any of both here, as only the ratio of both will be relevant for the Sudakov. <>= procedure :: powheg_kinematic_factors_real => & pcm_nlo_workspace_powheg_kinematic_factors_real <>= module function pcm_nlo_workspace_powheg_kinematic_factors_real & (pcm_work, sqme_real, alr) result (sqme_real_corr) real(default) :: sqme_real_corr class(pcm_nlo_workspace_t), intent(in) :: pcm_work real(default), intent(in) :: sqme_real integer, intent(in) :: alr end function pcm_nlo_workspace_powheg_kinematic_factors_real <>= module function pcm_nlo_workspace_powheg_kinematic_factors_real & (pcm_work, sqme_real, alr) result (sqme_real_corr) real(default) :: sqme_real_corr class(pcm_nlo_workspace_t), intent(in) :: pcm_work real(default), intent(in) :: sqme_real integer, intent(in) :: alr real(default) :: xi_max, jac_rand integer :: i_phs xi_max = pcm_work%get_xi_max (alr) i_phs = pcm_work%real_kinematics%alr_to_i_phs (alr) jac_rand = pcm_work%real_kinematics%jac_rand (i_phs) sqme_real_corr = sqme_real / xi_max / jac_rand end function pcm_nlo_workspace_powheg_kinematic_factors_real @ %def pcm_nlo_workspace_powheg_kinematic_factors_real @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \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]]>>= <> module kinematics <> use lorentz use physics_defs use sf_base use phs_base use fks_regions use mci_base use process_config use process_mci use pcm_base, only: pcm_t, pcm_workspace_t use pcm, only: pcm_nlo_t, pcm_nlo_workspace_t <> <> <> interface <> end interface end module kinematics @ %def kinematics @ <<[[kinematics_sub.f90]]>>= <> submodule (kinematics) kinematics_s <> use format_utils, only: write_separator use diagnostics use io_units use phs_points, only: assignment(=), size use interactions use phs_fks use ttv_formfactors, only: m1s_to_mpole implicit none contains <> end submodule kinematics_s @ %def kinematics_s @ <>= public :: kinematics_t <>= 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 <> end type kinematics_t @ %def kinematics_t @ Output. Show only those components which are marked as owned. <>= procedure :: write => kinematics_write <>= module subroutine kinematics_write (object, unit) class(kinematics_t), intent(in) :: object integer, intent(in), optional :: unit end subroutine kinematics_write <>= module 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. <>= procedure :: final => kinematics_final <>= module subroutine kinematics_final (object) class(kinematics_t), intent(inout) :: object end subroutine kinematics_final <>= module 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 @ Configure the kinematics object. This consists of several configuration steps which correspond to individual procedures. In essence, we configure the structure-function part, the partonic phase-space part, and various NLO items. TODO wk 19-03-01: This includes some region-data setup within [[pcm]], hence [[pcm]] is intent(inout). This should be moved elsewhere, so [[pcm]] can become strictly intent(in). <>= procedure :: configure => kinematics_configure <>= module subroutine kinematics_configure (kin, pcm, pcm_work, & sf_chain, beam_config, phs_config, nlo_type, is_i_sub) class(kinematics_t), intent(out) :: kin class(pcm_t), intent(inout) :: pcm class(pcm_workspace_t), intent(in) :: pcm_work 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 integer, intent(in) :: nlo_type logical, intent(in) :: is_i_sub end subroutine kinematics_configure <>= module subroutine kinematics_configure (kin, pcm, pcm_work, & sf_chain, beam_config, phs_config, nlo_type, is_i_sub) class(kinematics_t), intent(out) :: kin class(pcm_t), intent(inout) :: pcm class(pcm_workspace_t), intent(in) :: pcm_work 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 integer, intent(in) :: nlo_type logical, intent(in) :: is_i_sub logical :: extended_sf extended_sf = nlo_type == NLO_DGLAP .or. & (nlo_type == NLO_REAL .and. is_i_sub) call kin%init_sf_chain (sf_chain, beam_config, & extended_sf = pcm%has_pdfs .and. extended_sf) !!! Add one for additional Born matrix element call kin%init_phs (phs_config) call kin%set_nlo_info (nlo_type) select type (phs => kin%phs) type is (phs_fks_t) call phs%allocate_momenta (phs_config, .not. (nlo_type == NLO_REAL)) select type (pcm) type is (pcm_nlo_t) call pcm%region_data%init_phs_identifiers (phs%phs_identifiers) !!! The triple select type pyramid of doom select type (pcm_work) type is (pcm_nlo_workspace_t) if (allocated (pcm_work%real_kinematics%alr_to_i_phs)) & call pcm%region_data%set_alr_to_i_phs (phs%phs_identifiers, & pcm_work%real_kinematics%alr_to_i_phs) end select end select end select end subroutine kinematics_configure @ %def kinematics_configure @ 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. <>= procedure :: set_nlo_info => kinematics_set_nlo_info <>= module subroutine kinematics_set_nlo_info (k, nlo_type) class(kinematics_t), intent(inout) :: k integer, intent(in) :: nlo_type end subroutine kinematics_set_nlo_info <>= module 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 @ <>= procedure :: set_threshold => kinematics_set_threshold <>= module subroutine kinematics_set_threshold (kin, factorization_mode) class(kinematics_t), intent(inout) :: kin integer, intent(in) :: factorization_mode end subroutine kinematics_set_threshold <>= module subroutine kinematics_set_threshold (kin, factorization_mode) class(kinematics_t), intent(inout) :: kin integer, intent(in) :: factorization_mode kin%threshold = factorization_mode == FACTORIZATION_THRESHOLD end subroutine kinematics_set_threshold @ %def kinematics_set_threshold @ 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. <>= procedure :: init_sf_chain => kinematics_init_sf_chain <>= module 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 end subroutine kinematics_init_sf_chain <>= module 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. <>= procedure :: init_phs => kinematics_init_phs <>= module subroutine kinematics_init_phs (k, config) class(kinematics_t), intent(inout) :: k class(phs_config_t), intent(in), target :: config end subroutine kinematics_init_phs <>= module 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 @ <>= procedure :: evaluate_radiation_kinematics => & kinematics_evaluate_radiation_kinematics <>= module subroutine kinematics_evaluate_radiation_kinematics (k, r_in) class(kinematics_t), intent(inout) :: k real(default), intent(in), dimension(:) :: r_in end subroutine kinematics_evaluate_radiation_kinematics <>= module 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) if (phs%mode == PHS_MODE_ADDITIONAL_PARTICLE) then call phs%generate_radiation_variables & (r_in(phs%n_r_born + 1 : phs%n_r_born + 3), & threshold = k%threshold) call phs%compute_cms_energy () end if end select end subroutine kinematics_evaluate_radiation_kinematics @ %def kinematics_evaluate_radiation_kinematics @ <>= procedure :: generate_fsr_in => kinematics_generate_fsr_in <>= module subroutine kinematics_generate_fsr_in (kin) class(kinematics_t), intent(inout) :: kin end subroutine kinematics_generate_fsr_in <>= module subroutine kinematics_generate_fsr_in (kin) class(kinematics_t), intent(inout) :: kin select type (phs => kin%phs) type is (phs_fks_t) call phs%generate_fsr_in () end select end subroutine kinematics_generate_fsr_in @ %def kinematics_generate_fsr_in @ <>= procedure :: compute_xi_ref_momenta => kinematics_compute_xi_ref_momenta <>= module 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 end subroutine kinematics_compute_xi_ref_momenta <>= module 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. <>= procedure :: compute_selected_channel => kinematics_compute_selected_channel <>= module 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 end subroutine kinematics_compute_selected_channel <>= module 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 (debug_on) call msg_debug2 (D_REAL, "phase space is phs_FKS") if (phs%q_defined) then call phs%get_born_momenta (p) if (debug_on) then call msg_debug2 (D_REAL, "q is defined") call msg_debug2 (D_REAL, "get_born_momenta called") end if 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. else k%phs_factor = 0 success = .false. end if end select end subroutine kinematics_compute_selected_channel @ %def kinematics_compute_selected_channel @ <>= procedure :: redo_sf_chain => kinematics_redo_sf_chain <>= module subroutine kinematics_redo_sf_chain (kin, mci_work, phs_channel) class(kinematics_t), intent(inout) :: kin type(mci_work_t), intent(in) :: mci_work integer, intent(in) :: phs_channel end subroutine kinematics_redo_sf_chain <>= module subroutine kinematics_redo_sf_chain (kin, mci_work, phs_channel) class(kinematics_t), intent(inout) :: kin 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 () sf_channel = kin%phs%config%get_sf_channel (phs_channel) call kin%sf_chain%compute_kinematics (sf_channel, x) end if end subroutine kinematics_redo_sf_chain @ %def kinematics_redo_sf_chain @ Complete kinematics by filling the non-selected phase-space parameter arrays. <>= procedure :: compute_other_channels => kinematics_compute_other_channels <>= module 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 end subroutine kinematics_compute_other_channels <>= module 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.) <>= procedure :: get_incoming_momenta => kinematics_get_incoming_momenta <>= module subroutine kinematics_get_incoming_momenta (k, p) class(kinematics_t), intent(in) :: k type(vector4_t), dimension(:), intent(out) :: p end subroutine kinematics_get_incoming_momenta <>= module 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 @ <>= procedure :: get_boost_to_lab => kinematics_get_boost_to_lab <>= module function kinematics_get_boost_to_lab (kin) result (lt) type(lorentz_transformation_t) :: lt class(kinematics_t), intent(in) :: kin end function kinematics_get_boost_to_lab <>= module function kinematics_get_boost_to_lab (kin) result (lt) type(lorentz_transformation_t) :: lt class(kinematics_t), intent(in) :: kin lt = kin%phs%get_lorentz_transformation () end function kinematics_get_boost_to_lab @ %def kinematics_get_boost_to_lab @ <>= procedure :: get_boost_to_cms => kinematics_get_boost_to_cms <>= module function kinematics_get_boost_to_cms (kin) result (lt) type(lorentz_transformation_t) :: lt class(kinematics_t), intent(in) :: kin end function kinematics_get_boost_to_cms <>= module function kinematics_get_boost_to_cms (kin) result (lt) type(lorentz_transformation_t) :: lt class(kinematics_t), intent(in) :: kin lt = inverse (kin%phs%get_lorentz_transformation ()) end function kinematics_get_boost_to_cms @ %def kinematics_get_boost_to_cms @ 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. <>= procedure :: recover_mcpar => kinematics_recover_mcpar <>= module 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 end subroutine kinematics_recover_mcpar <>= module 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. <>= procedure :: recover_sfchain => kinematics_recover_sfchain <>= module subroutine kinematics_recover_sfchain (k, channel, p) class(kinematics_t), intent(inout) :: k integer, intent(in) :: channel type(vector4_t), dimension(:), intent(in) :: p end subroutine kinematics_recover_sfchain <>= module 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. <>= procedure :: get_mcpar => kinematics_get_mcpar <>= module 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 end subroutine kinematics_get_mcpar <>= module 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. <>= procedure :: evaluate_sf_chain => kinematics_evaluate_sf_chain <>= module subroutine kinematics_evaluate_sf_chain & (k, fac_scale, negative_sf, sf_rescale) class(kinematics_t), intent(inout) :: k real(default), intent(in) :: fac_scale logical, intent(in), optional :: negative_sf class(sf_rescale_t), intent(inout), optional :: sf_rescale end subroutine kinematics_evaluate_sf_chain <>= module subroutine kinematics_evaluate_sf_chain & (k, fac_scale, negative_sf, sf_rescale) class(kinematics_t), intent(inout) :: k real(default), intent(in) :: fac_scale logical, intent(in), optional :: negative_sf 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, negative_sf = negative_sf, & sf_rescale = 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. <>= procedure :: return_beam_momenta => kinematics_return_beam_momenta <>= module subroutine kinematics_return_beam_momenta (k) class(kinematics_t), intent(in) :: k end subroutine kinematics_return_beam_momenta <>= module 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. <>= procedure :: lab_is_cm => kinematics_lab_is_cm <>= module function kinematics_lab_is_cm (k) result (lab_is_cm) logical :: lab_is_cm class(kinematics_t), intent(in) :: k end function kinematics_lab_is_cm <>= module function kinematics_lab_is_cm (k) result (lab_is_cm) logical :: lab_is_cm class(kinematics_t), intent(in) :: k lab_is_cm = k%phs%config%lab_is_cm end function kinematics_lab_is_cm @ %def kinematics_lab_is_cm @ <>= procedure :: modify_momenta_for_subtraction => & kinematics_modify_momenta_for_subtraction <>= module 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 end subroutine kinematics_modify_momenta_for_subtraction <>= module 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 @ <>= procedure :: threshold_projection => kinematics_threshold_projection <>= module subroutine kinematics_threshold_projection (k, pcm_work, nlo_type) class(kinematics_t), intent(inout) :: k type(pcm_nlo_workspace_t), intent(inout) :: pcm_work integer, intent(in) :: nlo_type end subroutine kinematics_threshold_projection <>= module subroutine kinematics_threshold_projection (k, pcm_work, nlo_type) class(kinematics_t), intent(inout) :: k type(pcm_nlo_workspace_t), intent(inout) :: pcm_work integer, intent(in) :: nlo_type real(default) :: sqrts, mtop type(lorentz_transformation_t) :: L_to_cms type(vector4_t), dimension(:), allocatable :: p_tot, p_onshell integer :: n_tot n_tot = k%phs%get_n_tot () allocate (p_tot (size (pcm_work%real_kinematics%p_born_cms%phs_point(1)))) select type (phs => k%phs) type is (phs_fks_t) p_tot = pcm_work%real_kinematics%p_born_cms%phs_point(1) 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_work%real_kinematics%p_born_cms%set_momenta (1, p_tot) p_onshell = pcm_work%real_kinematics%p_born_onshell%phs_point(1) call threshold_projection_born (mtop, L_to_cms, p_tot, p_onshell) pcm_work%real_kinematics%p_born_onshell%phs_point(1) = p_onshell if (debug2_active (D_THRESHOLD)) then print *, 'On-shell projected Born: ' call vector4_write_set (p_onshell) end if end subroutine kinematics_threshold_projection @ %def kinematics_threshold_projection @ <>= procedure :: evaluate_radiation => kinematics_evaluate_radiation <>= module 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 end subroutine kinematics_evaluate_radiation <>= module 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%lab_is_cm () .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]]>>= <> module instances <> <> use lorentz use mci_base use particles use sm_qcd, only: qcd_t use quantum_numbers use interactions use model_data use variables use sf_base use pdf, only: pdf_data_t use physics_defs use process_constants use state_matrices use phs_base use prc_core, only: prc_core_t, prc_core_state_t !!! local modules use parton_states use process_counter use pcm_base use pcm use process_config use process_mci use process use kinematics <> <> <> <> interface <> end interface contains <> end module instances @ %def instances @ <<[[instances_sub.f90]]>>= <> submodule (instances) instances_s <> use io_units use format_utils, only: write_separator use constants use diagnostics use numeric_utils use helicities use flavors use pdg_arrays, only: is_quark, is_charged_lepton, flv_eqv_expr_class !!! 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_omega, only: prc_omega_t, omega_state_t use prc_external, only: prc_external_t, prc_external_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 prc_recola, only: prc_recola_t use blha_olp_interfaces, only: blha_color_c_fill_offdiag, blha_color_c_fill_diag use ttv_formfactors, only: m1s_to_mpole implicit none contains <> end submodule instances_s @ %def instances_s @ \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 [[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. Although each [[term_instance]] carries a [[weight]], this currently always keeps the value $1$ and is only used to be given to routines to fulfill their signature. <>= type :: term_instance_t type(process_term_t), pointer :: config => null () class(pcm_t), pointer :: pcm => null () class(pcm_workspace_t), pointer :: pcm_work => null () logical :: active = .false. 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. logical, dimension(:), allocatable :: passed_array integer, dimension(:), allocatable :: i_flv_to_i_flv_rep real(default) :: scale = 0 real(default), allocatable :: fac_scale real(default), allocatable :: ren_scale real(default), allocatable :: es_scale real(default), allocatable :: alpha_qcd_forced real(default) :: weight = 1 type(vector4_t), dimension(:), allocatable :: p_seed type(vector4_t), dimension(:), allocatable :: p_hard integer :: nlo_type = BORN integer, dimension(:), allocatable :: same_kinematics logical :: negative_sf = .false. logical :: flv_dep_cut_eval = .false. contains <> end type term_instance_t @ %def term_instance_t @ <>= procedure :: write => term_instance_write <>= module subroutine term_instance_write & (term, unit, kin, show_eff_state, testflag) class(term_instance_t), intent(in) :: term integer, intent(in), optional :: unit type(kinematics_t), intent(in), optional :: kin logical, intent(in), optional :: show_eff_state logical, intent(in), optional :: testflag end subroutine term_instance_write <>= module subroutine term_instance_write & (term, unit, kin, show_eff_state, testflag) class(term_instance_t), intent(in) :: term integer, intent(in), optional :: unit type(kinematics_t), intent(in), optional :: kin logical, intent(in), optional :: show_eff_state logical, intent(in), optional :: testflag real(default) :: fac_scale, ren_scale 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%get_fac_scale () write (u, "(3x,A,ES19.12)") "renormalization scale = ", term%get_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 !!! This used to be a member of term_instance if (present (kin)) then call kin%write (u) end if 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. <>= procedure :: final => term_instance_final <>= module subroutine term_instance_final (term) class(term_instance_t), intent(inout) :: term end subroutine term_instance_final <>= module 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%ren_scale)) deallocate (term%ren_scale) if (allocated (term%fac_scale)) deallocate (term%fac_scale) if (allocated (term%es_scale)) deallocate (term%es_scale) 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%connected%final () call term%isolated%final () call term%int_hard%final () term%pcm => null () term%pcm_work => null () end subroutine term_instance_final @ %def term_instance_final @ For a new term object, we configure the structure-function interface, the phase space, the matrix-element (interaction) interface, etc. <>= procedure :: configure => term_instance_configure <>= module subroutine term_instance_configure & (term_instance, process, i, pcm_work, sf_chain, kin) class(term_instance_t), intent(out), target :: term_instance type(process_t), intent(in), target :: process integer, intent(in) :: i class(pcm_workspace_t), intent(in), target :: pcm_work type(sf_chain_t), intent(in), target :: sf_chain type(kinematics_t), intent(inout), target :: kin end subroutine term_instance_configure <>= module subroutine term_instance_configure & (term_instance, process, i, pcm_work, sf_chain, kin) class(term_instance_t), intent(out), target :: term_instance type(process_t), intent(in), target :: process integer, intent(in) :: i class(pcm_workspace_t), intent(in), target :: pcm_work type(sf_chain_t), intent(in), target :: sf_chain type(kinematics_t), intent(inout), target :: kin 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 call term_instance%init & (process%get_pcm_ptr (), pcm_work, 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_dynamics (process, i, kin, & real_finite = process%component_is_real_finite (i_component)) select type (phs => kin%phs) type is (phs_fks_t) call term_instance%set_emitter (kin) call term_instance%setup_fks_kinematics (kin, & process%get_var_list_ptr (), & process%get_beam_config_ptr ()) end select select type (pcm => term_instance%pcm) type is (pcm_nlo_t) call kin%set_threshold (pcm%settings%factorization_mode) end select call term_instance%setup_expressions (process%get_meta (), process%get_config ()) end if end subroutine term_instance_configure @ %def term_instance_configure @ First part of term-instance configuration: initialize by assigning pointers to the overall [[pcm]] and the associated [[pcm_workspace]] objects. <>= procedure :: init => term_instance_init <>= module subroutine term_instance_init & (term_instance, pcm, pcm_work, nlo_type) class(term_instance_t), intent(out) :: term_instance class(pcm_t), intent(in), target :: pcm class(pcm_workspace_t), intent(in), target :: pcm_work integer, intent(in) :: nlo_type end subroutine term_instance_init <>= module subroutine term_instance_init (term_instance, pcm, pcm_work, nlo_type) class(term_instance_t), intent(out) :: term_instance class(pcm_t), intent(in), target :: pcm class(pcm_workspace_t), intent(in), target :: pcm_work integer, intent(in) :: nlo_type term_instance%pcm => pcm term_instance%pcm_work => pcm_work term_instance%nlo_type = nlo_type end subroutine term_instance_init @ %def term_instance_init @ The second part of term-instance configuration concerns dynamics, i.e., the interface to the matrix-element (interaction), and the parton-state objects that combine all kinematics and matrix-element data for evaluation. 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. <>= procedure :: setup_dynamics => term_instance_setup_dynamics <>= module subroutine term_instance_setup_dynamics & (term, process, i_term, kin, real_finite) class(term_instance_t), intent(inout), target :: term type(process_t), intent(in), target:: process integer, intent(in) :: i_term type(kinematics_t), intent(in) :: kin logical, intent(in), optional :: real_finite end subroutine term_instance_setup_dynamics <>= module subroutine term_instance_setup_dynamics & (term, process, i_term, kin, real_finite) class(term_instance_t), intent(inout), target :: term type(process_t), intent(in), target:: process integer, intent(in) :: i_term type(kinematics_t), intent(in) :: kin 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, dimension(:,:), allocatable :: flv_born, flv_real type(flavor_t), dimension(:,:), allocatable :: flv_pdf type(quantum_numbers_t), dimension(:,:), allocatable :: qn_pdf integer :: n_in, n_vir, n_out, n_tot, n_sub integer :: n_flv_born, n_flv_real, n_flv_total 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) term%negative_sf = process%get_negative_sf () call core%allocate_workspace (term%core_state) select type (core) class is (prc_external_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 => kin%sf_chain%get_out_int_ptr () n_in = term%int_hard%get_n_in () do j = 1, n_in i = kin%sf_chain%get_out_i (j) call term%int_hard%set_source_link (j, sf_chain_int, i) end do call term%isolated%init (kin%sf_chain, term%int_hard) allocate (mask_in (n_in)) mask_in = kin%sf_chain%get_out_mask () select type (phs => kin%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_beams_rescaled + term%get_n_sub () 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, & requires_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 () select type (pcm => term%pcm) type is (pcm_nlo_t) term%flv_dep_cut_eval = pcm%settings%nlo_correction_type == "EW" & .and. pcm%region_data%alphas_power > 0 & .and. any(is_charged_lepton(f_out%get_pdg())) end select 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) ! Does connected%trace never have any helicity qn? call term%init_interaction_qn_index (core, term%connected%trace, n_sub, & process%get_model_ptr (), is_polarized = .false.) call term%init_interaction_qn_index & (core, term%int_hard, n_sub, process%get_model_ptr ()) call term%init_eqv_expr_classes () if (requires_extended_sf) then select type (pcm => term%pcm) type is (pcm_nlo_t) n_in = pcm%region_data%get_n_in () flv_born = pcm%region_data%get_flv_states_born () flv_real = pcm%region_data%get_flv_states_real () n_flv_born = pcm%region_data%get_n_flv_born () n_flv_real = pcm%region_data%get_n_flv_real () n_flv_total = n_flv_born + n_flv_real allocate (flv_pdf(n_in, n_flv_total), & qn_pdf(n_in, n_flv_total)) call flv_pdf(:, :n_flv_born)%init (flv_born(:n_in, :)) call flv_pdf(:, n_flv_born + 1:n_flv_total)%init (flv_real(:n_in, :)) call qn_pdf%init (flv_pdf) call sf_chain_int%init_qn_index (qn_pdf, n_flv_born, n_flv_real) end select end if 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_external_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 reduce_interaction end subroutine term_instance_setup_dynamics @ %def term_instance_setup_dynamics @ Set up index mapping from state matrix to index pair [[i_flv]], [[i_sub]]. <>= public :: setup_interaction_qn_index <>= module subroutine setup_interaction_qn_index & (int, data, qn_config, n_sub, is_polarized) class(interaction_t), intent(inout) :: int class(process_constants_t), intent(in) :: data type(quantum_numbers_t), dimension(:, :), intent(in) :: qn_config integer, intent(in) :: n_sub logical, intent(in) :: is_polarized end subroutine setup_interaction_qn_index <>= module subroutine setup_interaction_qn_index & (int, data, qn_config, n_sub, is_polarized) class(interaction_t), intent(inout) :: int class(process_constants_t), intent(in) :: data type(quantum_numbers_t), dimension(:, :), intent(in) :: qn_config integer, intent(in) :: n_sub logical, intent(in) :: is_polarized integer :: i type(quantum_numbers_t), dimension(:, :), allocatable :: qn_hel if (is_polarized) then call setup_interaction_qn_hel (int, data, qn_hel) call int%init_qn_index (qn_config, n_sub, qn_hel) call int%set_qn_index_helicity_flip (.true.) else call int%init_qn_index (qn_config, n_sub) end if end subroutine setup_interaction_qn_index @ %def setup_interaction_qn_index @ Set up beam polarisation quantum numbers, if 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 an 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. <>= public :: setup_interaction_qn_hel <>= module subroutine setup_interaction_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 end subroutine setup_interaction_qn_hel <>= module subroutine setup_interaction_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_interaction_qn_hel @ %def setup_interaction_qn_hel @ Initialization of equivalent cut expression classes. Each flavor index [[i_flv]] here is assigned to the corresponding one representative for an equivalent cut expression class. This class describes the set of flavor quantum numbers for which the phase space cut expression evaluation yield the same output. The representative [[i_flv]] for one class correspond to the first flavor quantum numbers of that kind occuring in the state matrix. <>= procedure :: init_eqv_expr_classes => term_instance_init_eqv_expr_classes <>= module subroutine term_instance_init_eqv_expr_classes (term) class(term_instance_t), intent(inout), target :: term end subroutine term_instance_init_eqv_expr_classes <>= module subroutine term_instance_init_eqv_expr_classes (term) class(term_instance_t), intent(inout), target :: term type(interaction_t), pointer :: src_int type(state_matrix_t), pointer :: state_matrix type(flavor_t), dimension(:), allocatable :: flv_src logical, dimension(:,:,:), allocatable :: eqv_expr_class logical, dimension (:), allocatable :: evaluated integer :: n_in, n_vir, n_out integer :: k, j, i 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 (eqv_expr_class (3, n_out, & term%connected%trace%get_qn_index_n_flv ())) do k = 1, term%connected%trace%get_qn_index_n_flv () 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 (k)) eqv_expr_class (:, j, k) = flv_eqv_expr_class (flv_src(i)%get_pdg()) deallocate (flv_src) end if end do end do if (term%flv_dep_cut_eval) then allocate (evaluated (term%connected%trace%get_qn_index_n_flv ())) evaluated = .false. allocate (term%i_flv_to_i_flv_rep (term%connected%trace%get_qn_index_n_flv ())) do i = 1, term%connected%trace%get_qn_index_n_flv () if (.not. evaluated (i)) then do k = i, term%connected%trace%get_qn_index_n_flv () if (same_eqv_expr_class(eqv_expr_class (:,:,i), eqv_expr_class (:,:,k))) then term%i_flv_to_i_flv_rep (k) = i evaluated (k) = .true. end if end do end if end do end if contains function same_eqv_expr_class (flv_mask1, flv_mask2) result (same) logical, dimension (:,:), intent(in) :: flv_mask1, flv_mask2 logical :: same integer :: l same = .true. do l = 1, size (flv_mask1, dim = 2) same = same .and. all (flv_mask1(:,l) .eqv. flv_mask2(:,l)) end do end function same_eqv_expr_class end subroutine term_instance_init_eqv_expr_classes @ %def term_instance_init_eqv_expr_classes @ <>= procedure :: init_interaction_qn_index => & term_instance_init_interaction_qn_index <>= module subroutine term_instance_init_interaction_qn_index (term, core, & int, n_sub, model, is_polarized) class(term_instance_t), intent(inout), target :: term class(prc_core_t), intent(in) :: core class(interaction_t), intent(inout) :: int integer, intent(in) :: n_sub class(model_data_t), intent(in) :: model logical, intent(in), optional :: is_polarized end subroutine term_instance_init_interaction_qn_index <>= module subroutine term_instance_init_interaction_qn_index (term, core, & int, n_sub, model, is_polarized) class(term_instance_t), intent(inout), target :: term class(prc_core_t), intent(in) :: core class(interaction_t), intent(inout) :: int integer, intent(in) :: n_sub class(model_data_t), intent(in) :: model logical, intent(in), optional :: is_polarized logical :: polarized type(quantum_numbers_t), dimension(:, :), allocatable :: qn_config integer, dimension(:,:), allocatable :: flv_born type(flavor_t), dimension(:), allocatable :: flv integer :: i select type (core) class is (prc_external_t) if (present (is_polarized)) then polarized = is_polarized else polarized = core%includes_polarization () end if select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) associate (is_born => .not. (term%nlo_type == NLO_REAL .and. & .not. term%is_subtraction ())) select type (pcm => term%pcm) type is (pcm_nlo_t) qn_config = pcm%get_qn (is_born) end select call setup_interaction_qn_index (int, term%config%data, & qn_config, n_sub, polarized) end associate class default call term%config%data%get_flv_state (flv_born) allocate (flv (size (flv_born, dim = 1))) allocate (qn_config (size (flv_born, dim = 1), size (flv_born, dim = 2))) do i = 1, core%data%n_flv call flv%init (flv_born(:,i), model) call qn_config(:, i)%init (flv) end do call setup_interaction_qn_index (int, term%config%data, & qn_config, n_sub, polarized) end select class default call int%init_qn_index () end select end subroutine term_instance_init_interaction_qn_index @ %def term_instance_init_interaction_qn_index @ <>= procedure :: setup_fks_kinematics => term_instance_setup_fks_kinematics <>= module subroutine term_instance_setup_fks_kinematics & (term, kin, var_list, beam_config) class(term_instance_t), intent(inout), target :: term type(kinematics_t), intent(inout) :: kin type(var_list_t), intent(in) :: var_list type(process_beam_config_t), intent(in) :: beam_config end subroutine term_instance_setup_fks_kinematics <>= module subroutine term_instance_setup_fks_kinematics & (term, kin, var_list, beam_config) class(term_instance_t), intent(inout), target :: term type(kinematics_t), intent(inout) :: kin 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 => kin%phs) type is (phs_fks_t) select type (pcm => term%pcm) type is (pcm_nlo_t) select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) call pcm%setup_phs_generator (pcm_work, & phs%generator, phs%config%sqrts, mode, singular_jacobian) if (beam_config%has_structure_function ()) then pcm_work%isr_kinematics%isr_mode = SQRTS_VAR else pcm_work%isr_kinematics%isr_mode = SQRTS_FIXED end if if (debug_on) call msg_debug & (D_PHASESPACE, "isr_mode: ", pcm_work%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 (pcm => term%pcm) type is (pcm_nlo_t) associate (settings => pcm%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 @ Set up 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. <>= procedure :: compute_seed_kinematics => term_instance_compute_seed_kinematics <>= module subroutine term_instance_compute_seed_kinematics & (term, kin, mci_work, phs_channel, success) class(term_instance_t), intent(inout), target :: term type(kinematics_t), intent(inout) :: kin type(mci_work_t), intent(in) :: mci_work integer, intent(in) :: phs_channel logical, intent(out) :: success end subroutine term_instance_compute_seed_kinematics <>= module subroutine term_instance_compute_seed_kinematics & (term, kin, mci_work, phs_channel, success) class(term_instance_t), intent(inout), target :: term type(kinematics_t), intent(inout) :: kin type(mci_work_t), intent(in) :: mci_work integer, intent(in) :: phs_channel logical, intent(out) :: success call kin%compute_selected_channel & (mci_work, phs_channel, term%p_seed, success) end subroutine term_instance_compute_seed_kinematics @ %def term_instance_compute_seed_kinematics @ <>= procedure :: evaluate_projections => term_instance_evaluate_projections <>= module subroutine term_instance_evaluate_projections (term, kin) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(inout) :: kin end subroutine term_instance_evaluate_projections <>= module subroutine term_instance_evaluate_projections (term, kin) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(inout) :: kin if (kin%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_work => term%pcm_work) type is (pcm_nlo_workspace_t) call kin%threshold_projection (pcm_work, term%nlo_type) end select end if end subroutine term_instance_evaluate_projections @ %def term_instance_evaluate_projections @ 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. <>= procedure :: compute_hard_kinematics => & term_instance_compute_hard_kinematics <>= module subroutine term_instance_compute_hard_kinematics & (term, kin, recover, skip_term, success) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(inout) :: kin integer, intent(in), optional :: skip_term logical, intent(in), optional :: recover logical, intent(out) :: success end subroutine term_instance_compute_hard_kinematics <>= module subroutine term_instance_compute_hard_kinematics & (term, kin, recover, skip_term, success) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(inout) :: kin integer, intent(in), optional :: skip_term logical, intent(in), optional :: recover 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 (present (recover)) then if (recover) return end if if (term%nlo_type == NLO_REAL .and. kin%emitter >= 0) then call kin%evaluate_radiation (term%p_seed, p, success) select type (pcm => term%pcm) type is (pcm_nlo_t) if (pcm%dalitz_plot%active) then if (kin%emitter > kin%n_in) then if (p(kin%emitter)**2 > tiny_07) & call pcm%register_dalitz_plot (kin%emitter, p) end if end if end select else if (is_subtraction_component (kin%emitter, term%nlo_type)) then call kin%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) if (debug_on) then call msg_debug2 (D_REAL, "inside compute_hard_kinematics") if (debug2_active (D_REAL)) call vector4_write_set (p) end if 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. <>= procedure :: recover_seed_kinematics => & term_instance_recover_seed_kinematics <>= module subroutine term_instance_recover_seed_kinematics & (term, kin, p_seed_ref) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(in) :: kin type(vector4_t), dimension(:), intent(in), optional :: p_seed_ref end subroutine term_instance_recover_seed_kinematics <>= module subroutine term_instance_recover_seed_kinematics & (term, kin, p_seed_ref) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(in) :: kin integer :: n_in type(vector4_t), dimension(:), intent(in), optional :: p_seed_ref n_in = kin%n_in call kin%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.) if (present (p_seed_ref)) then term%p_seed(n_in + 1 : ) = p_seed_ref else term%p_seed(n_in + 1 : ) = int_eff%get_momenta (outgoing = .true.) end if 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. JRR: Obsolete now. <>= procedure :: compute_other_channels => & term_instance_compute_other_channels <>= 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. JRR: Obsolete now. <>= procedure :: return_beam_momenta => term_instance_return_beam_momenta <>= 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 @ Applies the real partition by computing the real partition function $F(\Phi)$ and multiplying either $\mathcal{R}_\text{sin} = \mathcal{R} \cdot F$ or $\mathcal{R}_\text{fin} = \mathcal{R} \cdot (1-F)$. <>= procedure :: apply_real_partition => term_instance_apply_real_partition <>= module subroutine term_instance_apply_real_partition (term, kin) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(in) :: kin end subroutine term_instance_apply_real_partition <>= module subroutine term_instance_apply_real_partition (term, kin) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(in) :: kin real(default) :: f, sqme integer :: i_component integer :: i_amp, n_amps, qn_index logical :: is_subtraction i_component = term%config%i_component select type (pcm => term%pcm) type is (pcm_nlo_t) if (pcm%component_selected (i_component) .and. & pcm%nlo_type (i_component) == NLO_REAL) then is_subtraction = pcm%component_type (i_component) == & COMP_REAL_SING .and. kin%emitter < 0 if (is_subtraction) return select case (pcm%component_type (i_component)) case (COMP_REAL_FIN) call term%connected%trace%set_duplicate_flv_zero() end select f = pcm%real_partition%get_f (term%p_hard) n_amps = term%connected%trace%get_n_matrix_elements () do i_amp = 1, n_amps qn_index = term%connected%trace%get_qn_index (i_amp, i_sub = 0) if (term%passed_array(i_amp) .or. .not. term%passed) then sqme = real (term%connected%trace%get_matrix_element (qn_index)) else sqme = zero end if if (debug_on) call msg_debug2 & (D_PROCESS_INTEGRATION, "term_instance_apply_real_partition") select case (pcm%component_type (i_component)) case (COMP_REAL_FIN) if (debug_on) call msg_debug2 & (D_PROCESS_INTEGRATION, "Real finite") sqme = sqme * (one - f) case (COMP_REAL_SING) if (debug_on) call msg_debug2 & (D_PROCESS_INTEGRATION, "Real singular") sqme = sqme * f end select if (debug_on) call msg_debug2 & (D_PROCESS_INTEGRATION, "apply_damping: sqme", sqme) call term%connected%trace%set_matrix_element & (qn_index, cmplx (sqme, zero, default)) end do end if end select end subroutine term_instance_apply_real_partition @ %def term_instance_apply_real_partition @ <>= procedure :: get_p_hard => term_instance_get_p_hard <>= pure module 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 end function term_instance_get_p_hard <>= pure module 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 @ <>= procedure :: set_emitter => term_instance_set_emitter <>= module subroutine term_instance_set_emitter (term, kin) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(inout) :: kin end subroutine term_instance_set_emitter <>= module subroutine term_instance_set_emitter (term, kin) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(inout) :: kin integer :: i_phs logical :: set_emitter select type (pcm => term%pcm) type is (pcm_nlo_t) select type (phs => kin%phs) type is (phs_fks_t) !!! Without resonances, i_alr = i_phs i_phs = term%config%i_term kin%i_phs = i_phs set_emitter = i_phs <= pcm%region_data%n_phs .and. & term%nlo_type == NLO_REAL if (set_emitter) then kin%emitter = phs%phs_identifiers(i_phs)%emitter select type (pcm => term%pcm) type is (pcm_nlo_t) if (allocated (pcm%region_data%i_phs_to_i_con)) & kin%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 @ For initializing the expressions, we need the local variable list and the parse trees. <>= procedure :: setup_expressions => term_instance_setup_expressions <>= module 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 end subroutine term_instance_setup_expressions <>= module 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 matrix elements we get from OpenLoops and GoSam are already squared and summed over color and helicity. They should not be squared again. <>= procedure :: setup_event_data => term_instance_setup_event_data <>= module subroutine term_instance_setup_event_data (term, kin, core, model) class(term_instance_t), intent(inout), target :: term type(kinematics_t), intent(in) :: kin class(prc_core_t), intent(in) :: core class(model_data_t), intent(in), target :: model end subroutine term_instance_setup_event_data <>= module subroutine term_instance_setup_event_data (term, kin, core, model) class(term_instance_t), intent(inout), target :: term type(kinematics_t), intent(in) :: kin class(prc_core_t), intent(in) :: core class(model_data_t), intent(in), target :: model integer :: n_in logical :: mask_color type(quantum_numbers_mask_t), dimension(:), allocatable :: mask_in n_in = term%int_hard%get_n_in () allocate (mask_in (n_in)) mask_in = kin%sf_chain%get_out_mask () call setup_isolated (term%isolated, core, model, mask_in, term%config%col) select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) mask_color = pcm_work%is_fixed_order_nlo_events () class default mask_color = .false. end select call setup_connected (term%connected, term%isolated, core, & term%nlo_type, mask_color) 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 select type (core) class is (prc_blha_t) call isolated%matrix%init_identity(isolated%int_eff) isolated%has_matrix = .true. class default call isolated%setup_square_matrix (core, model, mask, color) end select !!! TODO (PS-09-10-20) We should not square the flows !!! if they come from BLHA either call isolated%setup_square_flows (core, model, mask) end subroutine setup_isolated subroutine setup_connected (connected, isolated, core, nlo_type, mask_color) type(connected_state_t), intent(inout), target :: connected type(isolated_state_t), intent(in), target :: isolated class(prc_core_t), intent(in) :: core integer, intent(in) :: nlo_type logical, intent(in) :: mask_color 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 do not 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 term%init_interaction_qn_index (core, connected%matrix, 0, model, & is_polarized = .false.) select type (core) class is (prc_blha_t) call connected%setup_connected_flows & (isolated, mask_color = mask_color) class default call connected%setup_connected_flows (isolated) end select 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. <>= procedure :: evaluate_color_correlations => & term_instance_evaluate_color_correlations <>= module subroutine term_instance_evaluate_color_correlations (term, core) class(term_instance_t), intent(inout) :: term class(prc_core_t), intent(inout) :: core end subroutine term_instance_evaluate_color_correlations <>= module 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_work => term%pcm_work) type is (pcm_nlo_workspace_t) select type (pcm => term%pcm) type is (pcm_nlo_t) if (debug_on) call msg_debug2 (D_SUBTRACTION, & "term_instance_evaluate_color_correlations: " // & "use_internal_color_correlations:", & pcm%settings%use_internal_color_correlations) if (debug_on) call msg_debug2 (D_SUBTRACTION, "fac_scale", term%get_fac_scale ()) do i_flv_born = 1, pcm%region_data%n_flv_born select case (term%nlo_type) case (NLO_REAL) call transfer_me_array_to_bij (pcm, i_flv_born, & pcm_work%real_sub%sqme_born (i_flv_born), & pcm_work%real_sub%sqme_born_color_c (:, :, i_flv_born)) case (NLO_MISMATCH) call transfer_me_array_to_bij (pcm, i_flv_born, & pcm_work%soft_mismatch%sqme_born (i_flv_born), & pcm_work%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 (pcm, i_flv_born, & -one, pcm_work%virtual%sqme_color_c (:, :, i_flv_born)) case (NLO_DGLAP) call transfer_me_array_to_bij (pcm, i_flv_born, & pcm_work%dglap_remnant%sqme_born (i_flv_born), & pcm_work%dglap_remnant%sqme_color_c_extra (:, :, 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 logical :: special_case_interferences integer :: i_color_c, i_sub, n_offset, i_qn real(default), dimension(:), allocatable :: sqme real(default) :: sqme_born_c if (debug_on) 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 special_case_interferences = & pcm%region_data%nlo_correction_type == "EW" n_offset = 0 if (term%nlo_type == NLO_VIRTUAL) then n_offset = 1 else if (pcm%has_pdfs .and. (term%is_subtraction () & .or. term%nlo_type == NLO_DGLAP)) then n_offset = n_beams_rescaled end if allocate (sqme (term%get_n_sub_color ()), source = zero) do i_sub = 1, term%get_n_sub_color () i_qn = term%connected%trace%get_qn_index (i_flv, i_sub = i_sub + n_offset) if (term%passed_array(i_flv) .or. .not. term%passed) then sqme(i_sub) = real(term%connected%trace%get_matrix_element (i_qn), default) else sqme(i_sub) = zero end if end do call blha_color_c_fill_offdiag (pcm%region_data%n_legs_born, & sqme, sqme_color_c) i_qn = term%connected%trace%get_qn_index (i_flv, i_sub = 0) if (term%passed_array(i_flv) .or. .not. term%passed) then sqme_born_c = real(term%connected%trace%get_matrix_element (i_qn), default) else sqme_born_c = zero end if call blha_color_c_fill_diag (sqme_born_c, & pcm%region_data%get_flv_states_born (i_flv), & sqme_color_c, special_case_interferences) end if end subroutine transfer_me_array_to_bij end subroutine term_instance_evaluate_color_correlations @ %def term_instance_evaluate_color_correlations @ <>= procedure :: evaluate_charge_correlations => & term_instance_evaluate_charge_correlations <>= module subroutine term_instance_evaluate_charge_correlations (term, core) class(term_instance_t), intent(inout) :: term class(prc_core_t), intent(inout) :: core end subroutine term_instance_evaluate_charge_correlations <>= module 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_work => term%pcm_work) type is (pcm_nlo_workspace_t) select type (pcm => term%pcm) type is (pcm_nlo_t) do i_flv_born = 1, pcm%region_data%n_flv_born select case (term%nlo_type) case (NLO_REAL) call transfer_me_array_to_bij (pcm, i_flv_born, & pcm_work%real_sub%sqme_born (i_flv_born), & pcm_work%real_sub%sqme_born_charge_c (:, :, i_flv_born)) case (NLO_MISMATCH) call transfer_me_array_to_bij (pcm, i_flv_born, & pcm_work%soft_mismatch%sqme_born (i_flv_born), & pcm_work%soft_mismatch%sqme_born_charge_c (:, :, i_flv_born)) case (NLO_VIRTUAL) call transfer_me_array_to_bij (pcm, i_flv_born, & one, pcm_work%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 real(default), 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) = -one sigma(flv_born%n_in + 1: ) = one 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. <>= procedure :: evaluate_spin_correlations => & term_instance_evaluate_spin_correlations <>= module subroutine term_instance_evaluate_spin_correlations (term, core) class(term_instance_t), intent(inout) :: term class(prc_core_t), intent(inout) :: core end subroutine term_instance_evaluate_spin_correlations <>= module 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_sub, i_emitter, emitter, i_qn integer :: n_flv, n_sub_color, n_sub_spin, n_offset,i,j real(default), dimension(1:3, 1:3) :: sqme_spin_c real(default), dimension(:), allocatable :: sqme_spin_c_all real(default), dimension(:), allocatable :: sqme_spin_c_arr if (debug_on) call msg_debug2 (D_PROCESS_INTEGRATION, & "term_instance_evaluate_spin_correlations") select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) if (pcm_work%real_sub%requires_spin_correlations () & .and. term%nlo_type == NLO_REAL) then select type (core) type is (prc_openloops_t) select type (pcm => term%pcm) type is (pcm_nlo_t) n_flv = term%connected%trace%get_qn_index_n_flv () n_sub_color = term%get_n_sub_color () n_sub_spin = term%get_n_sub_spin () n_offset = 0; if(pcm%has_pdfs) n_offset = n_beams_rescaled allocate (sqme_spin_c_arr(6)) do i_flv = 1, n_flv allocate (sqme_spin_c_all(n_sub_spin)) do i_sub = 1, n_sub_spin i_qn = term%connected%trace%get_qn_index (i_flv, & i_sub = i_sub + n_offset + n_sub_color) if (term%passed_array(i_flv) .or. .not. term%passed) then sqme_spin_c_all(i_sub) = & real(term%connected%trace%get_matrix_element (i_qn), default) else sqme_spin_c_all(i_sub) = zero end if end do do i_emitter = 1, pcm%region_data%n_emitters emitter = pcm%region_data%emitters(i_emitter) if (emitter > 0) then call split_array (sqme_spin_c_all, sqme_spin_c_arr) do j = 1, size (sqme_spin_c, dim=2) do i = j, size (sqme_spin_c, dim=1) !!! Restoring the symmetric matrix packed into a 1-dim array !!! c.f. [[prc_openloops_compute_sqme_spin_c]] sqme_spin_c(i,j) = sqme_spin_c_arr(j + i * (i - 1) / 2) if (i /= j) sqme_spin_c(j,i) = sqme_spin_c(i,j) end do end do pcm_work%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 @ <>= procedure :: apply_fks => term_instance_apply_fks <>= module subroutine term_instance_apply_fks & (term, kin, alpha_s_sub, alpha_qed_sub) class(term_instance_t), intent(inout) :: term class(kinematics_t), intent(inout) :: kin real(default), intent(in) :: alpha_s_sub, alpha_qed_sub end subroutine term_instance_apply_fks <>= module subroutine term_instance_apply_fks & (term, kin, alpha_s_sub, alpha_qed_sub) class(term_instance_t), intent(inout) :: term class(kinematics_t), intent(inout) :: kin real(default), intent(in) :: alpha_s_sub, alpha_qed_sub real(default), dimension(:), allocatable :: sqme integer :: i, i_phs, emitter, i_qn logical :: is_subtraction select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) select type (pcm => term%pcm) type is (pcm_nlo_t) if (term%connected%has_matrix) then allocate (sqme (pcm%get_n_alr ())) else allocate (sqme (1)) end if sqme = zero select type (phs => kin%phs) type is (phs_fks_t) if (pcm%has_pdfs .and. & pcm%settings%use_internal_color_correlations) then call msg_fatal ("Color correlations for proton processes " // & "so far only supported by OpenLoops.") end if call pcm_work%set_real_and_isr_kinematics & (phs%phs_identifiers, kin%phs%get_sqrts ()) if (kin%emitter < 0) then call pcm_work%set_subtraction_event () do i_phs = 1, pcm%region_data%n_phs emitter = phs%phs_identifiers(i_phs)%emitter call pcm_work%real_sub%compute (emitter, & i_phs, alpha_s_sub, alpha_qed_sub, term%connected%has_matrix, sqme) end do else call pcm_work%set_radiation_event () emitter = kin%emitter; i_phs = kin%i_phs do i = 1, term%connected%trace%get_qn_index_n_flv () i_qn = term%connected%trace%get_qn_index (i) if (term%passed_array(i) .or. .not. term%passed) then pcm_work%real_sub%sqme_real_non_sub (i, i_phs) = & real (term%connected%trace%get_matrix_element (i_qn)) else pcm_work%real_sub%sqme_real_non_sub (i, i_phs) = zero end if end do call pcm_work%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 (pcm => term%pcm) type is (pcm_nlo_t) is_subtraction = kin%emitter < 0 if (term%connected%has_matrix) & call refill_evaluator (cmplx (sqme * term%weight, 0, default), & pcm%get_qn (is_subtraction), & pcm%region_data%get_flavor_indices (is_subtraction), & term%connected%matrix) if (term%connected%has_flows) & call refill_evaluator (cmplx (sqme * term%weight, 0, default), & pcm%get_qn (is_subtraction), & pcm%region_data%get_flavor_indices (is_subtraction), & term%connected%flows) end select end subroutine term_instance_apply_fks @ %def term_instance_apply_fks @ <>= procedure :: evaluate_sqme_virt => term_instance_evaluate_sqme_virt <>= module 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 end subroutine term_instance_evaluate_sqme_virt <>= module 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), dimension(2) :: alpha_coupling type(vector4_t), dimension(:), allocatable :: p_born real(default), dimension(:), allocatable :: sqme_virt integer :: i_flv, i_qn_born, i_qn_virt 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%get_ren_scale () print *, 'fac_scale: ', term%get_fac_scale () if (allocated (term%es_scale)) then print *, 'ES scale: ', term%es_scale else print *, 'ES scale: ', term%get_ren_scale () end if end if select type (pcm => term%pcm) type is (pcm_nlo_t) select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) alpha_coupling = [alpha_s, alpha_qed] if (debug2_active (D_VIRTUAL)) then print *, 'alpha_s: ', alpha_coupling (1) print *, 'alpha_qed: ', alpha_coupling (2) end if allocate (p_born (pcm%region_data%n_legs_born)) if (pcm%settings%factorization_mode == FACTORIZATION_THRESHOLD) then p_born = pcm_work%real_kinematics%p_born_onshell%get_momenta(1) else p_born = term%int_hard%get_momenta () end if call pcm_work%set_momenta_and_scales_virtual & (p_born, term%ren_scale, term%get_fac_scale (), & term%es_scale) select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) associate (virtual => pcm_work%virtual) do i_flv = 1, term%connected%trace%get_qn_index_n_flv () i_qn_born = term%connected%trace%get_qn_index (i_flv, i_sub = 0) i_qn_virt = term%connected%trace%get_qn_index (i_flv, i_sub = 1) if (term%passed_array(i_flv) .or. .not. term%passed) then virtual%sqme_born(i_flv) = & real (term%connected%trace%get_matrix_element (i_qn_born)) virtual%sqme_virt_fin(i_flv) = & real (term%connected%trace%get_matrix_element (i_qn_virt)) else virtual%sqme_born(i_flv) = zero virtual%sqme_virt_fin(i_flv) = zero end if end do end associate end select call pcm_work%compute_sqme_virt (term%pcm, term%p_hard, & alpha_coupling, term%connected%has_matrix, sqme_virt) call term%connected%trace%set_only_matrix_element & (1, cmplx (sum(sqme_virt), 0, default)) if (term%connected%has_matrix) & call refill_evaluator (cmplx (sqme_virt * term%weight, & 0, default), pcm%get_qn (.true.), & remove_duplicates_from_int_array ( & pcm%region_data%get_flavor_indices (.true.)), & term%connected%matrix) if (term%connected%has_flows) & call refill_evaluator (cmplx (sqme_virt * term%weight, & 0, default), pcm%get_qn (.true.), & remove_duplicates_from_int_array ( & pcm%region_data%get_flavor_indices (.true.)), & term%connected%flows) end select end select end subroutine term_instance_evaluate_sqme_virt @ %def term_instance_evaluate_sqme_virt @ Needs generalization to electroweak corrections. <>= procedure :: evaluate_sqme_mismatch => term_instance_evaluate_sqme_mismatch <>= module subroutine term_instance_evaluate_sqme_mismatch (term, alpha_s) class(term_instance_t), intent(inout) :: term real(default), intent(in) :: alpha_s end subroutine term_instance_evaluate_sqme_mismatch <>= module 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_work => term%pcm_work) type is (pcm_nlo_workspace_t) call pcm_work%compute_sqme_mismatch & (term%pcm, 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 (pcm => term%pcm) type is (pcm_nlo_t) if (term%connected%has_matrix) & call refill_evaluator (cmplx (sqme_mism * term%weight, 0, default), & pcm%get_qn (.true.), & remove_duplicates_from_int_array ( & pcm%region_data%get_flavor_indices (.true.)), & term%connected%matrix) if (term%connected%has_flows) & call refill_evaluator (cmplx (sqme_mism * term%weight, 0, default), & pcm%get_qn (.true.), & remove_duplicates_from_int_array ( & pcm%region_data%get_flavor_indices (.true.)), & term%connected%flows) end select end if end subroutine term_instance_evaluate_sqme_mismatch @ %def term_instance_evaluate_sqme_mismatch @ <>= procedure :: evaluate_sqme_dglap => term_instance_evaluate_sqme_dglap <>= module subroutine term_instance_evaluate_sqme_dglap & (term, alpha_s, alpha_qed) class(term_instance_t), intent(inout) :: term real(default), intent(in) :: alpha_s, alpha_qed end subroutine term_instance_evaluate_sqme_dglap <>= module subroutine term_instance_evaluate_sqme_dglap (term, alpha_s, alpha_qed) class(term_instance_t), intent(inout) :: term real(default), intent(in) :: alpha_s, alpha_qed real(default), dimension(2) :: alpha_coupling 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.") if (debug_on) call msg_debug2 & (D_PROCESS_INTEGRATION, "term_instance_evaluate_sqme_dglap") select type (pcm => term%pcm) type is (pcm_nlo_t) select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) alpha_coupling = [alpha_s,alpha_qed] if (debug2_active (D_PROCESS_INTEGRATION)) then associate (n_flv => pcm_work%dglap_remnant%reg_data%n_flv_born) print *, "size(sqme_born) = ", & size (pcm_work%dglap_remnant%sqme_born) call term%connected%trace%write () end associate end if call pcm_work%compute_sqme_dglap_remnant (pcm, alpha_coupling, & term%connected%has_matrix, sqme_dglap) end select 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 (pcm => term%pcm) type is (pcm_nlo_t) call refill_evaluator (cmplx (sqme_dglap * term%weight, 0, default), & pcm%get_qn (.true.), & remove_duplicates_from_int_array ( & pcm%region_data%get_flavor_indices (.true.)), & term%connected%matrix) if (term%connected%has_flows) then call refill_evaluator & (cmplx (sqme_dglap * term%weight, 0, default), & pcm%get_qn (.true.), & remove_duplicates_from_int_array ( & pcm%region_data%get_flavor_indices (.true.)), & term%connected%flows) end if 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. <>= procedure :: reset => term_instance_reset <>= module subroutine term_instance_reset (term) class(term_instance_t), intent(inout) :: term end subroutine term_instance_reset <>= module 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. <>= procedure :: set_alpha_qcd_forced => term_instance_set_alpha_qcd_forced <>= module subroutine term_instance_set_alpha_qcd_forced (term, alpha_qcd) class(term_instance_t), intent(inout) :: term real(default), intent(in) :: alpha_qcd end subroutine term_instance_set_alpha_qcd_forced <>= module 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. The final step of kinematics setup is to transfer the effective kinematics to the evaluators and to the [[subevt]]. <>= procedure :: compute_eff_kinematics => & term_instance_compute_eff_kinematics <>= module subroutine term_instance_compute_eff_kinematics (term) class(term_instance_t), intent(inout) :: term end subroutine term_instance_compute_eff_kinematics <>= module 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 <>= procedure :: recover_hard_kinematics => & term_instance_recover_hard_kinematics <>= module subroutine term_instance_recover_hard_kinematics (term) class(term_instance_t), intent(inout) :: term end subroutine term_instance_recover_hard_kinematics <>= module 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. <>= procedure :: evaluate_expressions => & term_instance_evaluate_expressions <>= module subroutine term_instance_evaluate_expressions & (term, config, scale_forced) class(term_instance_t), intent(inout) :: term type(process_beam_config_t), intent(in) :: config real(default), intent(in), allocatable, optional :: scale_forced end subroutine term_instance_evaluate_expressions <>= module subroutine term_instance_evaluate_expressions & (term, config, scale_forced) class(term_instance_t), intent(inout) :: term type(process_beam_config_t), intent(in) :: config real(default), intent(in), allocatable, optional :: scale_forced real(default) :: scale = 0 real(default) :: weight = 1 real(default), allocatable :: fac_scale, ren_scale type(interaction_t), pointer :: src_int type(state_matrix_t), pointer :: state_matrix type(flavor_t), dimension(:), allocatable :: flv_int, flv_src, f_in, f_out logical :: passed integer :: n_in, n_vir, n_out, n_tot, n_flv integer :: i, j, k n_flv = term%connected%trace%get_qn_index_n_flv () if (.not. allocated (term%passed_array)) allocate (term%passed_array(n_flv)) if (term%flv_dep_cut_eval) then do k = 1, n_flv if (k == term%i_flv_to_i_flv_rep(k)) then n_in = term%int_hard%get_n_in () 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 (k)) 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 (k)) f_out(j) = flv_src(i) deallocate (flv_src) end if end do call term%connected%renew_flv_content_subevt & (term%isolated%sf_chain_eff, & config%data%flv, f_in, f_out) call term%connected%evaluate_expressions (passed, & scale, fac_scale, ren_scale, weight, & scale_forced, force_evaluation = .true.) if (k == 1) then term%scale = scale if (allocated (fac_scale)) then if (.not. allocated (term%fac_scale)) then allocate (term%fac_scale, source = fac_scale) else term%fac_scale = fac_scale end if end if if (allocated (ren_scale)) then if (.not. allocated (term%ren_scale)) then allocate (term%ren_scale, source = ren_scale) else term%ren_scale = ren_scale end if end if term%weight = weight end if term%passed_array(k) = passed deallocate (f_in) deallocate (f_out) else term%passed_array(k) = term%passed_array(term%i_flv_to_i_flv_rep(k)) end if end do term%passed = any (term%passed_array) else call term%connected%evaluate_expressions (term%passed, & term%scale, term%fac_scale, term%ren_scale, term%weight, & scale_forced, force_evaluation = .true.) term%passed_array = term%passed end if 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. <>= procedure :: evaluate_interaction => term_instance_evaluate_interaction <>= module subroutine term_instance_evaluate_interaction (term, core, kin) class(term_instance_t), intent(inout) :: term class(prc_core_t), intent(in), pointer :: core type(kinematics_t), intent(inout) :: kin end subroutine term_instance_evaluate_interaction <>= module subroutine term_instance_evaluate_interaction (term, core, kin) class(term_instance_t), intent(inout) :: term class(prc_core_t), intent(in), pointer :: core type(kinematics_t), intent(inout) :: kin if (debug_on) call msg_debug2 (D_PROCESS_INTEGRATION, & "term_instance_evaluate_interaction") if (kin%only_cm_frame .and. (.not. kin%lab_is_cm())) then term%p_hard = kin%get_boost_to_cms () * term%int_hard%get_momenta () else term%p_hard = term%int_hard%get_momenta () end if select type (core) class is (prc_external_t) call term%evaluate_interaction_external (core, kin) 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 @ <>= procedure :: evaluate_interaction_default & => term_instance_evaluate_interaction_default <>= module subroutine term_instance_evaluate_interaction_default (term, core) class(term_instance_t), intent(inout) :: term class(prc_core_t), intent(in) :: core end subroutine term_instance_evaluate_interaction_default <>= module subroutine term_instance_evaluate_interaction_default (term, core) class(term_instance_t), intent(inout) :: term class(prc_core_t), intent(in) :: core real(default) :: fac_scale, ren_scale integer :: i if (allocated (term%fac_scale)) then fac_scale = term%fac_scale else fac_scale = term%scale end if if (allocated (term%ren_scale)) then ren_scale = term%ren_scale else ren_scale = term%scale end if 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), & fac_scale, ren_scale, term%alpha_qcd_forced, & term%core_state) end do select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) call pcm_work%set_fac_scale (fac_scale) end select end subroutine term_instance_evaluate_interaction_default @ %def term_instance_evaluate_interaction_default @ <>= procedure :: evaluate_interaction_external & => term_instance_evaluate_interaction_external <>= module subroutine term_instance_evaluate_interaction_external & (term, core, kin) class(term_instance_t), intent(inout) :: term class(prc_core_t), intent(inout) :: core type(kinematics_t), intent(inout) :: kin end subroutine term_instance_evaluate_interaction_external <>= module subroutine term_instance_evaluate_interaction_external & (term, core, kin) class(term_instance_t), intent(inout) :: term class(prc_core_t), intent(inout) :: core type(kinematics_t), intent(inout) :: kin if (debug_on) call msg_debug2 (D_PROCESS_INTEGRATION, & "term_instance_evaluate_interaction_external") 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%get_ren_scale ()) if (allocated (core_state%threshold_data)) & call evaluate_threshold_parameters (core_state, core, kin%phs%get_sqrts ()) end select class is (prc_external_state_t) select type (core) class is (prc_external_t) call core%compute_alpha_s (core_state, term%get_ren_scale ()) end select end select call evaluate_threshold_interaction () if (term%nlo_type == NLO_VIRTUAL) then call term%evaluate_interaction_external_loop (core) else call term%evaluate_interaction_external_tree (core) end if select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) call pcm_work%set_fac_scale (term%get_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_work => term%pcm_work) type is (pcm_nlo_workspace_t) if (kin%emitter >= 0) then call core%set_offshell_momenta & (pcm_work%real_kinematics%p_real_cms%get_momenta(term%config%i_term)) leg = thr_leg (kin%emitter) call core%set_leg (leg) call core%set_onshell_momenta & (pcm_work%real_kinematics%p_real_onshell(leg)%get_momenta(term%config%i_term)) else call core%set_leg (0) call core%set_offshell_momenta & (pcm_work%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_external @ %def term_instance_evaluate_interaction_external @ 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_beams_rescaled]] copies of these matrix elements as the first [[n_beams_rescaled]] subtractions. This is a remnant from times before the method [[term_instance_set_sf_factors]] and these entries are not used anymore. However, eliminating these entries involves deeper changes in how the connection tables for the evaluator product are set up and should therefore be part of a larger refactoring of the interactions \& state matrices. The next $n_{\text{born}}\times n_{sub_color}$ are color-correlated Born matrix elements, with then again the next $n_{\text{born}}\times n_{emitters}\times n_{sub_spin}$ being spin-correlated Born matrix elements. If two or more flavor structures would produce the same amplitude we only compute one and use the [[eqv_index]] determined by the [[prc_core]] and just copy the result to improve performance. <>= procedure :: evaluate_interaction_external_tree & => term_instance_evaluate_interaction_external_tree <>= module subroutine term_instance_evaluate_interaction_external_tree & (term, core) class(term_instance_t), intent(inout) :: term class(prc_core_t), intent(inout) :: core end subroutine term_instance_evaluate_interaction_external_tree <>= module subroutine term_instance_evaluate_interaction_external_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(6) :: 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_color_c_eqv, & i_spin_c, i_spin_c_eqv integer :: i_flv_eqv, i_hel_eqv integer :: emitter, i_emitter logical :: bad_point, bp logical, dimension(:,:), allocatable :: eqv_me_evaluated if (debug_on) call msg_debug2 (D_PROCESS_INTEGRATION, & "term_instance_evaluate_interaction_external_tree") allocate (sqme_color_c (blha_result_array_size & (term%int_hard%get_n_tot (), BLHA_AMP_COLOR_C))) n_flv = term%int_hard%get_qn_index_n_flv () n_hel = term%int_hard%get_qn_index_n_hel () n_sub_color = term%get_n_sub_color () n_sub_spin = term%get_n_sub_spin () allocate (eqv_me_evaluated(n_flv,n_hel)) eqv_me_evaluated = .false. do i_flv = 1, n_flv if (.not. term%passed_array(i_flv) .and. term%passed) cycle do i_hel = 1, n_hel i_flv_eqv = core%data%eqv_flv_index(i_flv) i_hel_eqv = core%data%eqv_hel_index(i_hel) if (.not. eqv_me_evaluated(i_flv_eqv, i_hel_eqv)) then select type (core) class is (prc_external_t) call core%update_alpha_s (term%core_state, term%get_ren_scale ()) call core%compute_sqme (i_flv, i_hel, term%p_hard, & term%get_ren_scale (), sqme, bad_point) call term%pcm_work%set_bad_point (bad_point) associate (i_int => term%int_hard%get_qn_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%has_pdfs .and. & (term%is_subtraction () .or. term%nlo_type == NLO_DGLAP)) then n_pdf_off = n_pdf_off + n_beams_rescaled do i_sub = 1, n_pdf_off term%amp(term%int_hard%get_qn_index (i_flv, i_hel, i_sub)) = & term%amp(term%int_hard%get_qn_index (i_flv, i_hel, i_sub = 0)) end do end if if (term%pcm%has_pdfs .and. term%nlo_type == NLO_DGLAP) then sqme_color_c = zero select type (pcm => term%pcm) type is (pcm_nlo_t) if (pcm%settings%nlo_correction_type == "EW" .and. & pcm%region_data%alphas_power > 0) then select type (core) class is (prc_blha_t) call core%compute_sqme_color_c_raw (i_flv, i_hel, & term%p_hard, term%get_ren_scale (), sqme_color_c, & bad_point) call term%pcm_work%set_bad_point (bad_point) class is (prc_recola_t) call core%compute_sqme_color_c_raw (i_flv, i_hel, & term%p_hard, term%get_ren_scale (), sqme_color_c, & bad_point) call term%pcm_work%set_bad_point (bad_point) end select end if end select do i_sub = 1, n_sub_color i_color_c = term%int_hard%get_qn_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 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%get_ren_scale (), sqme_color_c, bad_point) call term%pcm_work%set_bad_point (bad_point) class is (prc_recola_t) call core%compute_sqme_color_c_raw (i_flv, i_hel, & term%p_hard, term%get_ren_scale (), sqme_color_c, bad_point) call term%pcm_work%set_bad_point (bad_point) end select do i_sub = 1, n_sub_color i_color_c = term%int_hard%get_qn_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 (pcm => term%pcm) type is (pcm_nlo_t) do i_emitter = 1, pcm%region_data%n_emitters emitter = pcm%region_data%emitters(i_emitter) if (emitter > 0) then call core%compute_sqme_spin_c & (i_flv, & i_hel, & emitter, & term%p_hard, & term%get_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%int_hard%get_qn_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 eqv_me_evaluated(i_flv_eqv, i_hel_eqv) = .true. else associate (i_int => term%int_hard%get_qn_index & (i_flv = i_flv, i_hel = i_hel, i_sub = 0), & i_int_eqv => term%int_hard%get_qn_index & (i_flv = i_flv_eqv, i_hel = i_hel_eqv, i_sub = 0)) term%amp(i_int) = term%amp(i_int_eqv) end associate n_pdf_off = 0 if (term%pcm%has_pdfs .and. & (term%is_subtraction () .or. term%nlo_type == NLO_DGLAP)) then n_pdf_off = n_pdf_off + n_beams_rescaled do i_sub = 1, n_pdf_off term%amp(term%int_hard%get_qn_index (i_flv, i_hel, i_sub)) = & term%amp(term%int_hard%get_qn_index (i_flv, i_hel, i_sub = 0)) end do end if if (term%pcm%has_pdfs .and. term%nlo_type == NLO_DGLAP) then do i_sub = 1, n_sub_color i_color_c = term%int_hard%get_qn_index & (i_flv, i_hel, i_sub + n_pdf_off) i_color_c_eqv = term%int_hard%get_qn_index & (i_flv_eqv, i_hel_eqv, i_sub + n_pdf_off) term%amp(i_color_c) = term%amp(i_color_c_eqv) end do end if if ((term%nlo_type == NLO_REAL .and. term%is_subtraction ()) .or. & term%nlo_type == NLO_MISMATCH) then do i_sub = 1, n_sub_color i_color_c = term%int_hard%get_qn_index & (i_flv, i_hel, i_sub + n_pdf_off) i_color_c_eqv = term%int_hard%get_qn_index & (i_flv_eqv, i_hel_eqv, i_sub + n_pdf_off) term%amp(i_color_c) = term%amp(i_color_c_eqv) end do do i_sub = 1, n_sub_spin i_spin_c = term%int_hard%get_qn_index (i_flv, i_hel, & i_sub + n_pdf_off + n_sub_color) i_spin_c_eqv = term%int_hard%get_qn_index (i_flv_eqv, i_hel_eqv, & i_sub + n_pdf_off + n_sub_color) term%amp(i_spin_c) = term%amp(i_spin_c_eqv) end do end if end if end do end do end subroutine term_instance_evaluate_interaction_external_tree @ %def term_instance_evaluate_interaction_external_tree @ Same as for [[term_instance_evaluate_interaction_external_tree]], but for the integrated-subtraction and finite one-loop terms. We only need color-correlated Born matrix elements, but an additional entry per flavor structure for the finite one-loop contribution. We thus have $2+n_{sub_color}$ entries in the [[term%amp]] for each [[i_flv]] and [[i_hel]] combination. If two or more flavor structures would produce the same amplitude we only compute one and use the [[eqv_index]] determined by the [[prc_core]] and just copy the result to improve performance. <>= procedure :: evaluate_interaction_external_loop & => term_instance_evaluate_interaction_external_loop <>= module subroutine term_instance_evaluate_interaction_external_loop & (term, core) class(term_instance_t), intent(inout) :: term class(prc_core_t), intent(in) :: core end subroutine term_instance_evaluate_interaction_external_loop <>= module subroutine term_instance_evaluate_interaction_external_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, i_color_c_eqv integer :: i_flv_eqv, i_hel_eqv real(default), dimension(4) :: sqme_virt real(default), dimension(:), allocatable :: sqme_color_c real(default) :: es_scale logical :: bad_point logical, dimension(:,:), allocatable :: eqv_me_evaluated if (debug_on) call msg_debug (D_PROCESS_INTEGRATION, & "term_instance_evaluate_interaction_external_loop") allocate (sqme_color_c (blha_result_array_size & (term%int_hard%get_n_tot (), BLHA_AMP_COLOR_C))) n_flv = term%int_hard%get_qn_index_n_flv () n_hel = term%int_hard%get_qn_index_n_hel () n_sub = term%int_hard%get_qn_index_n_sub () allocate (eqv_me_evaluated(n_flv,n_hel)) eqv_me_evaluated = .false. i_virt = 1 do i_flv = 1, n_flv if (.not. term%passed_array(i_flv) .and. term%passed) cycle do i_hel = 1, n_hel i_flv_eqv = core%data%eqv_flv_index(i_flv) i_hel_eqv = core%data%eqv_hel_index(i_hel) if (.not. eqv_me_evaluated(i_flv_eqv, i_hel_eqv)) then select type (core) class is (prc_external_t) if (allocated (term%es_scale)) then es_scale = term%es_scale else es_scale = term%get_ren_scale () end if call core%compute_sqme_virt (i_flv, i_hel, term%p_hard, & term%get_ren_scale (), es_scale, & term%pcm%blha_defaults%loop_method, & sqme_virt, bad_point) call term%pcm_work%set_bad_point (bad_point) end select associate (i_born => term%int_hard%get_qn_index (i_flv, i_hel = i_hel, i_sub = 0), & i_loop => term%int_hard%get_qn_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 (pcm => term%pcm) 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%get_ren_scale (), & sqme_color_c, bad_point) call term%pcm_work%set_bad_point (bad_point) do i_sub = 1 + i_virt, n_sub i_color_c = term%int_hard%get_qn_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 type is (prc_recola_t) call core%compute_sqme_color_c_raw (i_flv, i_hel, & term%p_hard, term%get_ren_scale (), sqme_color_c, bad_point) call term%pcm_work%set_bad_point (bad_point) do i_sub = 1 + i_virt, n_sub i_color_c = term%int_hard%get_qn_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 eqv_me_evaluated(i_flv_eqv, i_hel_eqv) = .true. else associate (i_born => term%int_hard%get_qn_index (i_flv, i_hel = i_hel, i_sub = 0), & i_loop => term%int_hard%get_qn_index (i_flv, i_hel = i_hel, i_sub = i_virt), & i_born_eqv => term%int_hard%get_qn_index & (i_flv_eqv, i_hel = i_hel_eqv, i_sub = 0), & i_loop_eqv => term%int_hard%get_qn_index & (i_flv_eqv, i_hel = i_hel_eqv, i_sub = 1)) term%amp(i_loop) = term%amp(i_loop_eqv) term%amp(i_born) = term%amp(i_born_eqv) end associate do i_sub = 1 + i_virt, n_sub i_color_c = term%int_hard%get_qn_index & (i_flv, i_hel = i_hel, i_sub = i_sub) i_color_c_eqv = term%int_hard%get_qn_index & (i_flv_eqv, i_hel = i_hel_eqv, i_sub = i_sub) ! Index shift: i_sub - i_virt term%amp(i_color_c) = term%amp(i_color_c_eqv) end do end if end do end do end subroutine term_instance_evaluate_interaction_external_loop @ %def term_instance_evaluate_interaction_external_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 [[kin]] and [[isolated]] differ. Next, evaluate the hard interaction, then compute the convolution with the initial state. <>= procedure :: evaluate_trace => term_instance_evaluate_trace <>= module subroutine term_instance_evaluate_trace (term, kin) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(inout) :: kin end subroutine term_instance_evaluate_trace <>= module subroutine term_instance_evaluate_trace (term, kin) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(inout) :: kin real(default) :: fac_scale if (allocated (term%fac_scale)) then fac_scale = term%fac_scale else fac_scale = term%scale end if call kin%evaluate_sf_chain (fac_scale, term%negative_sf) call term%evaluate_scaled_sf_chains (kin) call term%isolated%evaluate_sf_chain (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, in which we have an emitter in the initial state, we rescale the kinematics for it using [[sf_rescale_real_t]]. The references are arXiv:0709.2092, Eqs.~(2.35)-(2.42). Obviously, it is completely irrelevant, which beam is treated. It becomes problematic when handling $ep$ collisions. Gfortran 7/8/9 bug, has to remain in the main module: <>= procedure :: evaluate_scaled_sf_chains => & term_instance_evaluate_scaled_sf_chains <>= subroutine term_instance_evaluate_scaled_sf_chains (term, kin) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(inout) :: kin class(sf_rescale_t), allocatable :: sf_rescale if (.not. term%pcm%has_pdfs) return if (term%nlo_type == NLO_REAL) then if (term%is_subtraction ()) then allocate (sf_rescale_collinear_t :: sf_rescale) select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) select type (sf_rescale) type is (sf_rescale_collinear_t) call sf_rescale%set (pcm_work%real_kinematics%xi_tilde) end select end select call kin%sf_chain%evaluate (term%get_fac_scale (), & term%negative_sf, sf_rescale) deallocate (sf_rescale) else if (kin%emitter >= 0 .and. kin%emitter <= kin%n_in) then allocate (sf_rescale_real_t :: sf_rescale) select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) select type (sf_rescale) type is (sf_rescale_real_t) call sf_rescale%set (pcm_work%real_kinematics%xi_tilde * & pcm_work%real_kinematics%xi_max (kin%i_phs), & pcm_work%real_kinematics%y (kin%i_phs)) end select end select call kin%sf_chain%evaluate (term%get_fac_scale (), & term%negative_sf, sf_rescale) deallocate (sf_rescale) else call kin%sf_chain%evaluate (term%get_fac_scale (), term%negative_sf) end if else if (term%nlo_type == NLO_DGLAP) then allocate (sf_rescale_dglap_t :: sf_rescale) select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) select type (sf_rescale) type is (sf_rescale_dglap_t) call sf_rescale%set (pcm_work%isr_kinematics%z) end select end select call kin%sf_chain%evaluate (term%get_fac_scale (), & term%negative_sf, sf_rescale) deallocate (sf_rescale) 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. <>= procedure :: evaluate_event_data => term_instance_evaluate_event_data <>= module subroutine term_instance_evaluate_event_data (term) class(term_instance_t), intent(inout) :: term end subroutine term_instance_evaluate_event_data <>= module 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 @ <>= procedure :: set_fac_scale => term_instance_set_fac_scale <>= module subroutine term_instance_set_fac_scale (term, fac_scale) class(term_instance_t), intent(inout) :: term real(default), intent(in) :: fac_scale end subroutine term_instance_set_fac_scale <>= module 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 and renormalization scale are identical to the general scale if not explicitly set: <>= procedure :: get_fac_scale => term_instance_get_fac_scale procedure :: get_ren_scale => term_instance_get_ren_scale <>= module function term_instance_get_fac_scale (term) result (fac_scale) class(term_instance_t), intent(in) :: term real(default) :: fac_scale end function term_instance_get_fac_scale module function term_instance_get_ren_scale (term) result (ren_scale) class(term_instance_t), intent(in) :: term real(default) :: ren_scale end function term_instance_get_ren_scale <>= module function term_instance_get_fac_scale (term) result (fac_scale) class(term_instance_t), intent(in) :: term real(default) :: fac_scale if (allocated (term%fac_scale)) then fac_scale = term%fac_scale else fac_scale = term%scale end if end function term_instance_get_fac_scale module function term_instance_get_ren_scale (term) result (ren_scale) class(term_instance_t), intent(in) :: term real(default) :: ren_scale if (allocated (term%ren_scale)) then ren_scale = term%ren_scale else ren_scale = term%scale end if end function term_instance_get_ren_scale @ %def term_instance_get_fac_scale term_instance_get_ren_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. <>= procedure :: get_alpha_s => term_instance_get_alpha_s <>= module 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 end function term_instance_get_alpha_s <>= module 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 @ The second helicity for [[helicities]] comes with a minus sign because OpenLoops inverts the helicity index of antiparticles. <>= procedure :: get_helicities_for_openloops => & term_instance_get_helicities_for_openloops <>= module subroutine term_instance_get_helicities_for_openloops & (term, helicities) class(term_instance_t), intent(in) :: term integer, dimension(:,:), allocatable, intent(out) :: helicities end subroutine term_instance_get_helicities_for_openloops <>= module 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 @ <>= procedure :: get_i_term_global => term_instance_get_i_term_global <>= elemental module function term_instance_get_i_term_global & (term) result (i_term) integer :: i_term class(term_instance_t), intent(in) :: term end function term_instance_get_i_term_global <>= elemental module 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 @ <>= procedure :: is_subtraction => term_instance_is_subtraction <>= elemental module function term_instance_is_subtraction (term) result (sub) logical :: sub class(term_instance_t), intent(in) :: term end function term_instance_is_subtraction <>= elemental module 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]]. <>= 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 <>= module function term_instance_get_n_sub (term) result (n_sub) integer :: n_sub class(term_instance_t), intent(in) :: term end function term_instance_get_n_sub module function term_instance_get_n_sub_color (term) result (n_sub_color) integer :: n_sub_color class(term_instance_t), intent(in) :: term end function term_instance_get_n_sub_color module function term_instance_get_n_sub_spin (term) result (n_sub_spin) integer :: n_sub_spin class(term_instance_t), intent(in) :: term end function term_instance_get_n_sub_spin <>= module 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 module 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 module 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} NOTE: The description below represents the intended structure after refactoring and disentangling the FKS-NLO vs. LO algorithm dependencies. 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 [[pcm]] pointer is a shortcut to the [[pcm]] (process-component manager) component of the associated process, which we need wherever the calculation depends on the overall algorithm. The [[pcm_work]] component is the workspace for the [[pcm]] object referenced above. 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 [[kinematics]] array contains the set of phase-space points that are associated with the current calculation. The entries may correspond to different process components and terms. (TODO wk 19-02-22: Not implemented yet.) TODO wk 19-02-22: May include extra arrays for storing (squared) amplitude data. The [[term]] data set may be reduced to just results, or be removed altogether. The [[term]] subobjects are workspace for evaluating kinematics, matrix elements, cuts etc. The array entries correspond to the [[term]] configuration entries in the associated process object. 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. <>= public :: process_instance_t <>= type, extends (mci_sampler_t) :: process_instance_t type(process_t), pointer :: process => null () class(pcm_t), pointer :: pcm => null () class(pcm_workspace_t), allocatable :: pcm_work integer :: evaluation_status = STAT_UNDEFINED real(default) :: sqme = 0 real(default) :: weight = 0 real(default) :: excess = 0 integer :: n_dropped = 0 integer :: i_mci = 0 integer :: selected_channel = 0 type(sf_chain_t) :: sf_chain type(kinematics_t), dimension(:), allocatable :: kin type(term_instance_t), dimension(:), allocatable :: term type(mci_work_t), dimension(:), allocatable :: mci_work class(process_instance_hook_t), pointer :: hook => null () contains <> end type process_instance_t @ %def process_instance @ Wrapper type for storing pointers to process instance objects in arrays. <>= public :: process_instance_ptr_t <>= 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 evaluated 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. <>= public :: process_instance_hook_t <>= 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 an [[init]], a [[final]] procedure and, for after evaluation, the [[evaluate]] procedure. The [[init]] procedures accesses [[var_list]] and current [[instance]] object. <>= public :: process_instance_hook_final, process_instance_hook_evaluate <>= abstract interface subroutine process_instance_hook_init (hook, var_list, instance, pdf_data) import :: process_instance_hook_t, var_list_t, process_instance_t, pdf_data_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 type(pdf_data_t), intent(in), optional :: pdf_data 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. <>= procedure :: write_header => process_instance_write_header procedure :: write => process_instance_write <>= module 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 end subroutine process_instance_write_header module subroutine process_instance_write (object, unit, testflag) class(process_instance_t), intent(in) :: object integer, intent(in), optional :: unit logical, intent(in), optional :: testflag end subroutine process_instance_write <>= module 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 module 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, & kin = object%kin(i), & 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]]. <>= procedure :: init => process_instance_init <>= module subroutine process_instance_init (instance, process) class(process_instance_t), intent(out), target :: instance type(process_t), intent(inout), target :: process end subroutine process_instance_init <>= module 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), pointer :: term type(var_list_t), pointer :: var_list integer :: i_born, i_real, i_real_fin, i_component if (debug_on) call msg_debug & (D_PROCESS_INTEGRATION, "process_instance_init") instance%process => process instance%pcm => process%get_pcm_ptr () 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_workspace (instance%pcm_work) 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_work each time. i_real_fin = process%get_associated_real_fin (1) if (.not. pcm%initialized) then i_born = pcm%get_i_core (pcm%i_born) i_real = pcm%get_i_core (pcm%i_real) call pcm%init_qn (process%get_model_ptr ()) if (i_real_fin > 0) call pcm%allocate_ps_matching () 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 if pcm%initialized = .true. select type (pcm_work => instance%pcm_work) type is (pcm_nlo_workspace_t) call pcm_work%init_config (pcm, & process%component_can_be_integrated (), & process%get_nlo_type_component (), process%get_energy (), & i_real_fin, process%get_model_ptr ()) end select end select ! TODO wk-03-01 n_terms will eventually acquire a different meaning allocate (instance%kin (process%get_n_terms ())) do i = 1, process%get_n_terms () term => process%get_term_ptr (i) i_component = term%i_component call instance%kin(i)%configure (pcm, instance%pcm_work, & instance%sf_chain, & process%get_beam_config_ptr (), & process%get_phs_config (i_component), & process%get_nlo_type_component (i_component), & term%i_sub == i) end do ! TODO wk-03-01 n_terms will eventually acquire a different meaning allocate (instance%term (process%get_n_terms ())) do i = 1, process%get_n_terms () call instance%term(i)%configure (process, i, instance%pcm_work, & instance%sf_chain, instance%kin(i)) 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. <>= procedure :: final => process_instance_final <>= module subroutine process_instance_final (instance) class(process_instance_t), intent(inout) :: instance end subroutine process_instance_final <>= module 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%kin)) then do i = 1, size (instance%kin) call instance%kin(i)%final () end do deallocate (instance%kin) end if 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_work%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. <>= procedure :: reset => process_instance_reset <>= module subroutine process_instance_reset (instance, reset_mci) class(process_instance_t), intent(inout), target :: instance logical, intent(in), optional :: reset_mci end subroutine process_instance_reset <>= module subroutine process_instance_reset (instance, reset_mci) class(process_instance_t), intent(inout), target :: 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%kin%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. <>= procedure :: sampler_test => process_instance_sampler_test <>= module 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 end subroutine process_instance_sampler_test <>= module 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. <>= procedure :: generate_weighted_event => & process_instance_generate_weighted_event <>= module subroutine process_instance_generate_weighted_event (instance, i_mci) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: i_mci end subroutine process_instance_generate_weighted_event <>= module 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 @ <>= procedure :: generate_unweighted_event => & process_instance_generate_unweighted_event <>= module subroutine process_instance_generate_unweighted_event & (instance, i_mci) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: i_mci end subroutine process_instance_generate_unweighted_event <>= module 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. <>= procedure :: recover_event => process_instance_recover_event <>= module subroutine process_instance_recover_event (instance) class(process_instance_t), intent(inout) :: instance end subroutine process_instance_recover_event <>= module 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. <>= procedure :: activate => process_instance_activate <>= module subroutine process_instance_activate (instance) class(process_instance_t), intent(inout) :: instance end subroutine process_instance_activate <>= module 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 @ <>= procedure :: find_same_kinematics => process_instance_find_same_kinematics <>= module subroutine process_instance_find_same_kinematics (instance) class(process_instance_t), intent(inout) :: instance end subroutine process_instance_find_same_kinematics <>= module 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%kin(i)%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%kin(j)%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 @ <>= procedure :: transfer_same_kinematics => & process_instance_transfer_same_kinematics <>= module subroutine process_instance_transfer_same_kinematics & (instance, i_term) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: i_term end subroutine process_instance_transfer_same_kinematics <>= module 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) instance%term(i_term_same)%p_seed = instance%term(i_term)%p_seed associate (phs => instance%kin(i_term_same)%phs) call phs%set_lorentz_transformation & (instance%kin(i_term)%phs%get_lorentz_transformation ()) select type (phs) type is (phs_fks_t) call phs%set_momenta (instance%term(i_term_same)%p_seed) if (i_term_same /= i_term) then call phs%set_reference_frames (.false.) end if end select end associate instance%kin(i_term_same)%new_seed = .false. end do end associate end subroutine process_instance_transfer_same_kinematics @ %def process_instance_transfer_same_kinematics @ <>= procedure :: redo_sf_chains => process_instance_redo_sf_chains <>= module 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 end subroutine process_instance_redo_sf_chains <>= module 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%kin(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). <>= procedure :: integrate => process_instance_integrate <>= module 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 end subroutine process_instance_integrate <>= module 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. <>= procedure :: setup_sf_chain => process_instance_setup_sf_chain <>= module subroutine process_instance_setup_sf_chain (instance, config) class(process_instance_t), intent(inout) :: instance type(process_beam_config_t), intent(in), target :: config end subroutine process_instance_setup_sf_chain <>= module 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. <>= procedure :: setup_event_data => process_instance_setup_event_data <>= module 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 end subroutine process_instance_setup_event_data <>= module 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), kin => instance%kin(i)) if (associated (term%config)) then core => instance%process%get_core_term (i) call term%setup_event_data (kin, 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. <>= procedure :: choose_mci => process_instance_choose_mci <>= module subroutine process_instance_choose_mci (instance, i_mci) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: i_mci end subroutine process_instance_choose_mci <>= module 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. <>= procedure :: set_mcpar => process_instance_set_mcpar <>= module 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 end subroutine process_instance_set_mcpar <>= module 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. <>= procedure :: receive_beam_momenta => process_instance_receive_beam_momenta <>= module subroutine process_instance_receive_beam_momenta (instance) class(process_instance_t), intent(inout) :: instance end subroutine process_instance_receive_beam_momenta <>= module 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. <>= procedure :: set_beam_momenta => process_instance_set_beam_momenta <>= module subroutine process_instance_set_beam_momenta (instance, p) class(process_instance_t), intent(inout) :: instance type(vector4_t), dimension(:), intent(in) :: p end subroutine process_instance_set_beam_momenta <>= module 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. <>= procedure :: recover_beam_momenta => process_instance_recover_beam_momenta <>= module subroutine process_instance_recover_beam_momenta (instance, i_term) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: i_term end subroutine process_instance_recover_beam_momenta <>= module 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 ()) then if (instance%evaluation_status >= STAT_EFF_KINEMATICS) then call instance%kin(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. <>= procedure :: select_channel => process_instance_select_channel <>= module subroutine process_instance_select_channel (instance, channel) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: channel end subroutine process_instance_select_channel <>= module 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. <>= procedure :: compute_seed_kinematics => & process_instance_compute_seed_kinematics <>= module subroutine process_instance_compute_seed_kinematics & (instance, recover, skip_term) class(process_instance_t), intent(inout) :: instance logical, intent(in), optional :: recover integer, intent(in), optional :: skip_term end subroutine process_instance_compute_seed_kinematics <>= module subroutine process_instance_compute_seed_kinematics & (instance, recover, skip_term) class(process_instance_t), intent(inout) :: instance logical, intent(in), optional :: recover 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 (present (recover)) then if (recover) return 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) associate (term => instance%term(i_term(j)), kin => instance%kin(i_term(j))) if (kin%new_seed) then call term%compute_seed_kinematics (kin, & instance%mci_work(instance%i_mci), channel, success) call instance%transfer_same_kinematics (i_term(j)) end if if (.not. success) exit select type (pcm => instance%pcm) class is (pcm_nlo_t) call term%evaluate_projections (kin) call kin%evaluate_radiation_kinematics & (instance%mci_work(instance%i_mci)%get_x_process ()) call kin%generate_fsr_in () call kin%compute_xi_ref_momenta (pcm%region_data, term%nlo_type) end select end associate 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_work => instance%pcm_work) class is (pcm_nlo_workspace_t) call pcm_work%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 @ <>= procedure :: get_x_process => process_instance_get_x_process <>= pure module function process_instance_get_x_process (instance) result (x) real(default), dimension(:), allocatable :: x class(process_instance_t), intent(in) :: instance end function process_instance_get_x_process <>= pure module 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 @ <>= procedure :: get_active_component_type => & process_instance_get_active_component_type <>= pure module function process_instance_get_active_component_type & (instance) result (nlo_type) integer :: nlo_type class(process_instance_t), intent(in) :: instance end function process_instance_get_active_component_type <>= pure module 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. <>= procedure :: recover_mcpar => process_instance_recover_mcpar <>= module subroutine process_instance_recover_mcpar (instance, i_term) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: i_term end subroutine process_instance_recover_mcpar <>= module subroutine process_instance_recover_mcpar (instance, i_term) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: i_term integer :: channel, i 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%kin(i_term)%recover_mcpar & (instance%mci_work(instance%i_mci), channel, instance%term(i_term)%p_seed) if (instance%term(i_term)%nlo_type == NLO_REAL) then do i = 1, size (instance%term) if (i /= i_term .and. instance%term(i)%nlo_type == NLO_REAL) then if (instance%term(i)%active) then call instance%kin(i)%recover_mcpar & (instance%mci_work(instance%i_mci), channel, & instance%term(i)%p_seed) end if end if end do end if 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. <>= procedure :: recover_sfchain => process_instance_recover_sfchain <>= module subroutine process_instance_recover_sfchain (instance, i_term) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: i_term end subroutine process_instance_recover_sfchain <>= module 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%kin(i_term)%recover_sfchain & (channel, instance%term(i_term)%p_seed) 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. <>= procedure :: compute_hard_kinematics => & process_instance_compute_hard_kinematics <>= module subroutine process_instance_compute_hard_kinematics & (instance, recover, skip_term) class(process_instance_t), intent(inout) :: instance integer, intent(in), optional :: skip_term logical, intent(in), optional :: recover end subroutine process_instance_compute_hard_kinematics <>= module subroutine process_instance_compute_hard_kinematics & (instance, recover, skip_term) class(process_instance_t), intent(inout) :: instance integer, intent(in), optional :: skip_term logical, intent(in), optional :: recover integer :: i logical :: success success = .true. if (instance%evaluation_status >= STAT_SEED_KINEMATICS) then do i = 1, size (instance%term) associate (term => instance%term(i), kin => instance%kin(i)) if (term%active) then call term%compute_hard_kinematics & (kin, recover, skip_term, success) if (.not. success) exit !!! Ren scale is zero when this is commented out! Understand! if (term%nlo_type == NLO_REAL) & call kin%redo_sf_chain (instance%mci_work(instance%i_mci), & instance%selected_channel) end if end associate 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. <>= procedure :: recover_seed_kinematics => & process_instance_recover_seed_kinematics <>= module subroutine process_instance_recover_seed_kinematics & (instance, i_term) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: i_term end subroutine process_instance_recover_seed_kinematics <>= module subroutine process_instance_recover_seed_kinematics (instance, i_term) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: i_term type(vector4_t), dimension(:), allocatable :: p_seed_ref integer :: i if (instance%evaluation_status >= STAT_EFF_KINEMATICS) then call instance%term(i_term)%recover_seed_kinematics (instance%kin(i_term)) if (instance%term(i_term)%nlo_type == NLO_REAL) then allocate (p_seed_ref & (instance%term(i_term)%isolated%int_eff%get_n_out ())) p_seed_ref = instance%term(i_term)%isolated%int_eff%get_momenta & (outgoing = .true.) do i = 1, size (instance%term) if (i /= i_term .and. instance%term(i)%nlo_type == NLO_REAL) then if (instance%term(i)%active) then call instance%term(i)%recover_seed_kinematics & (instance%kin(i), p_seed_ref) end if end if end do end if end if 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. <>= procedure :: compute_eff_kinematics => & process_instance_compute_eff_kinematics <>= module subroutine process_instance_compute_eff_kinematics & (instance, skip_term) class(process_instance_t), intent(inout) :: instance integer, intent(in), optional :: skip_term end subroutine process_instance_compute_eff_kinematics <>= module 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. <>= procedure :: recover_hard_kinematics => & process_instance_recover_hard_kinematics <>= module subroutine process_instance_recover_hard_kinematics & (instance, i_term) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: i_term end subroutine process_instance_recover_hard_kinematics <>= module 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 successful, 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. <>= procedure :: evaluate_expressions => & process_instance_evaluate_expressions <>= module subroutine process_instance_evaluate_expressions & (instance, scale_forced) class(process_instance_t), intent(inout) :: instance real(default), intent(in), allocatable, optional :: scale_forced end subroutine process_instance_evaluate_expressions <>= module 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 & (instance%process%get_beam_config (), scale_forced) end if end do call evaluate_real_scales_and_cuts () call set_ellis_sexton_scale () 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 (pcm => instance%pcm) 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 (pcm%settings%cut_all_real_sqmes) & passed_real = passed_real .and. instance%term(i)%passed if (pcm%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 subroutine set_ellis_sexton_scale () real(default) :: es_scale type(var_list_t), pointer :: var_list integer :: i var_list => instance%process%get_var_list_ptr () es_scale = var_list%get_rval (var_str ("ellis_sexton_scale")) do i = 1, size (instance%term) if (instance%term(i)%active .and. instance%term(i)%nlo_type == NLO_VIRTUAL) then if (es_scale > zero) then if (allocated (instance%term(i)%es_scale)) then instance%term(i)%es_scale = es_scale else allocate (instance%term(i)%es_scale, source=es_scale) end if end if end if end do end subroutine set_ellis_sexton_scale 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. <>= procedure :: compute_other_channels => & process_instance_compute_other_channels <>= module subroutine process_instance_compute_other_channels & (instance, skip_term) class(process_instance_t), intent(inout) :: instance integer, intent(in), optional :: skip_term end subroutine process_instance_compute_other_channels <>= module 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%kin(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 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. <>= procedure :: reset_core_kinematics => process_instance_reset_core_kinematics <>= module subroutine process_instance_reset_core_kinematics (instance) class(process_instance_t), intent(inout) :: instance end subroutine process_instance_reset_core_kinematics <>= module 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. <>= procedure :: evaluate_trace => process_instance_evaluate_trace <>= module subroutine process_instance_evaluate_trace (instance, recover) class(process_instance_t), intent(inout) :: instance logical, intent(in), optional :: recover end subroutine process_instance_evaluate_trace <>= module subroutine process_instance_evaluate_trace (instance, recover) class(process_instance_t), intent(inout) :: instance logical, intent(in), optional :: recover class(prc_core_t), pointer :: core => null () integer :: i, i_real_fin, i_core, i_qn, i_flv real(default) :: alpha_s, alpha_qed, pt class(prc_core_t), pointer :: core_sub => null () class(model_data_t), pointer :: model => null () logical :: has_pdfs if (debug_on) call msg_debug2 (D_PROCESS_INTEGRATION, "process_instance_evaluate_trace") has_pdfs = instance%process%pcm_contains_pdfs () instance%sqme = zero select type (pcm_work => instance%pcm_work) type is (pcm_nlo_workspace_t) if (allocated(pcm_work%real_sub%sqme_real_arr)) then pcm_work%real_sub%sqme_real_arr = zero end if end select call instance%reset_matrix_elements () if (instance%evaluation_status >= STAT_PASSED_CUTS) then do i = 1, size (instance%term) associate (term => instance%term(i), kin => instance%kin(i)) if (term%active .and. term%passed) then core => instance%process%get_core_term (i) select type (pcm => instance%process%get_pcm_ptr ()) class is (pcm_nlo_t) i_core = pcm%get_i_core (pcm%i_sub) core_sub => instance%process%get_core_ptr (i_core) end select call term%evaluate_interaction (core, kin) call term%evaluate_trace (kin) i_real_fin = instance%process%get_associated_real_fin (1) if (instance%process%uses_real_partition ()) & call term%apply_real_partition (kin) if (term%config%i_component == i_real_fin) then if (term%nlo_type == NLO_REAL .and. .not. term%is_subtraction ()) then !!! Force the scale pT into the events for the real finite associate (p_hard => term%p_hard) !!! This is only the correct pt for ISR pt = transverse_part(p_hard(size(p_hard))) call term%set_fac_scale (pt) select type (core) class is (prc_external_t) select type (core_state => term%core_state) class is (prc_external_state_t) core_state%alpha_qcd = core%qcd%alpha%get (pt) end select type is (prc_omega_t) select type (core_state => term%core_state) type is (omega_state_t) core_state%alpha_qcd = core%qcd%alpha%get (pt) end select end select end associate end if else if (term%nlo_type == BORN) then do i_flv = 1, term%connected%trace%get_qn_index_n_flv () i_qn = term%connected%trace%get_qn_index (i_flv, i_sub = 0) if (.not. term%passed_array(i_flv)) then call term%connected%trace%set_matrix_element & (i_qn, cmplx (zero, zero, default)) end if end do end if if ((term%nlo_type == NLO_REAL .and. kin%emitter < 0) & .or. term%nlo_type == NLO_MISMATCH & .or. term%nlo_type == NLO_DGLAP) & call term%set_born_sqmes (core) if (term%is_subtraction () .or. & term%nlo_type == NLO_DGLAP) & call term%set_sf_factors (kin, has_pdfs) if (term%nlo_type > BORN) then if (.not. (term%nlo_type == NLO_REAL .and. & kin%emitter >= 0)) then select type (pcm => term%pcm) type is (pcm_nlo_t) if (char (pcm%settings%nlo_correction_type) == "QCD" .or. & char (pcm%settings%nlo_correction_type) == "Full") & call term%evaluate_color_correlations (core_sub) if (char (pcm%settings%nlo_correction_type) == "EW" .or. & char (pcm%settings%nlo_correction_type) == "Full") then call term%evaluate_charge_correlations (core_sub) select type (pcm => term%pcm) type is (pcm_nlo_t) associate (reg_data => pcm%region_data) if (reg_data%alphas_power > 0) & call term%evaluate_color_correlations (core_sub) end associate end select end if end select end if if (term%is_subtraction ()) then call term%evaluate_spin_correlations (core_sub) end if end if alpha_s = core%get_alpha_s (term%core_state) alpha_qed = core%get_alpha_qed (term%core_state) if (term%nlo_type > BORN) then select type (pcm => term%pcm) type is (pcm_nlo_t) if (alpha_qed == -1 .and. (& char (pcm%settings%nlo_correction_type) == "EW" .or. & char (pcm%settings%nlo_correction_type) == "Full")) then call msg_bug("Attempting to compute EW corrections with alpha_qed = -1") end if end select end if if (present (recover)) then if (recover) return end if select case (term%nlo_type) case (NLO_REAL) call term%apply_fks (kin, 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, alpha_qed) 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_work%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 <>= procedure :: set_born_sqmes => term_instance_set_born_sqmes <>= module subroutine term_instance_set_born_sqmes (term, core) class(term_instance_t), intent(inout) :: term class(prc_core_t), intent(in) :: core end subroutine term_instance_set_born_sqmes <>= module 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_work => term%pcm_work) type is (pcm_nlo_workspace_t) do i_flv = 1, term%connected%trace%get_qn_index_n_flv () ii_flv = term%connected%trace%get_qn_index (i_flv, i_sub = 0) if (term%passed_array (i_flv) .or. .not. term%passed) then sqme = real (term%connected%trace%get_matrix_element (ii_flv)) else sqme = zero end if select case (term%nlo_type) case (NLO_REAL) pcm_work%real_sub%sqme_born(i_flv) = sqme case (NLO_MISMATCH) pcm_work%soft_mismatch%sqme_born(i_flv) = sqme case (NLO_DGLAP) pcm_work%dglap_remnant%sqme_born(i_flv) = sqme end select end do end select end subroutine term_instance_set_born_sqmes @ %def term_instance_set_born_sqmes @ Calculates and then saves the ratio of the value of the (rescaled) real structure function chain of each ISR alpha region over the value of the corresponding underlying born flavor structure. In the case of emitter 0 we also need the rescaled ratio for emitter 1 and 2 in that region for the (soft-)collinear limits. If the emitter is 1 or 2 in some cases, e. g. for EW corrections where a photon in the proton is required, there can be the possibility of soft radiation off the initial state. For that purpose the unrescaled ratio is needed and as a default we always save these numbers in [[sf_factors(:,0)]]. Although this procedure is implying functionality for general structure functions, it should be reviewed for anything else besides PDFs, as there might be complications in the details. The general idea of getting the ratio in this way should hold up in these cases as well, however. <>= procedure :: set_sf_factors => term_instance_set_sf_factors <>= module subroutine term_instance_set_sf_factors (term, kin, has_pdfs) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(inout) :: kin logical, intent(in) :: has_pdfs end subroutine term_instance_set_sf_factors <>= module subroutine term_instance_set_sf_factors (term, kin, has_pdfs) class(term_instance_t), intent(inout) :: term type(kinematics_t), intent(inout) :: kin logical, intent(in) :: has_pdfs type(interaction_t), pointer :: sf_chain_int real(default) :: factor_born, factor_real integer :: n_in, alr, em integer :: i_born, i_real select type (pcm_work => term%pcm_work) type is (pcm_nlo_workspace_t) if (.not. has_pdfs) then pcm_work%real_sub%sf_factors = one return end if select type (pcm => term%pcm) type is (pcm_nlo_t) sf_chain_int => kin%sf_chain%get_out_int_ptr () associate (reg_data => pcm%region_data) n_in = reg_data%get_n_in () do alr = 1, reg_data%n_regions em = reg_data%regions(alr)%emitter if (em <= n_in) then i_born = reg_data%regions(alr)%uborn_index i_real = reg_data%regions(alr)%real_index factor_born = sf_chain_int%get_matrix_element & (sf_chain_int%get_sf_qn_index_born (i_born, i_sub = 0)) factor_real = sf_chain_int%get_matrix_element & (sf_chain_int%get_sf_qn_index_real (i_real, i_sub = em)) call set_factor (pcm_work, alr, em, factor_born, factor_real) if (em == 0) then do em = 1, 2 factor_real = sf_chain_int%get_matrix_element & (sf_chain_int%get_sf_qn_index_real (i_real, i_sub = em)) call set_factor (pcm_work, alr, em, factor_born, factor_real) end do else factor_real = sf_chain_int%get_matrix_element & (sf_chain_int%get_sf_qn_index_real (i_real, i_sub = 0)) call set_factor (pcm_work, alr, 0, factor_born, factor_real) end if end if end do end associate end select end select contains subroutine set_factor (pcm_work, alr, em, factor_born, factor_real) type(pcm_nlo_workspace_t), intent(inout), target :: pcm_work integer, intent(in) :: alr, em real(default), intent(in) :: factor_born, factor_real real(default) :: factor if (any (vanishes ([factor_real, factor_born], tiny(1._default), tiny(1._default)))) then factor = zero else factor = factor_real / factor_born end if select case (term%nlo_type) case (NLO_REAL) pcm_work%real_sub%sf_factors(alr, em) = factor case (NLO_DGLAP) pcm_work%dglap_remnant%sf_factors(alr, em) = factor end select end subroutine end subroutine term_instance_set_sf_factors @ %def term_instance_set_sf_factors @ <>= procedure :: apply_real_partition => process_instance_apply_real_partition <>= module subroutine process_instance_apply_real_partition (instance) class(process_instance_t), intent(inout) :: instance end subroutine process_instance_apply_real_partition <>= module 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 ( & instance%kin(i_terms(i_term))) 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 @ <>= procedure :: set_i_mci_to_real_component => & process_instance_set_i_mci_to_real_component <>= module subroutine process_instance_set_i_mci_to_real_component (instance) class(process_instance_t), intent(inout) :: instance end subroutine process_instance_set_i_mci_to_real_component <>= module 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_work => instance%pcm_work) type is (pcm_nlo_workspace_t) if (allocated (pcm_work%i_mci_to_real_component)) then call msg_warning & ("i_mci_to_real_component already allocated - replace it") deallocate (pcm_work%i_mci_to_real_component) end if allocate (pcm_work%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_work%i_mci_to_real_component (i_mci) = & component%config%get_associated_real () case (COMP_REAL_FIN) pcm_work%i_mci_to_real_component (i_mci) = & component%config%get_associated_real_fin () case (COMP_REAL_SING) pcm_work%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. <>= procedure :: evaluate_event_data => process_instance_evaluate_event_data <>= module subroutine process_instance_evaluate_event_data (instance, weight) class(process_instance_t), intent(inout) :: instance real(default), intent(in), optional :: weight end subroutine process_instance_evaluate_event_data <>= module 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) 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%n_dropped = & instance%mci_work(instance%i_mci)%mci%get_n_event_dropped () instance%evaluation_status = STAT_EVENT_COMPLETE else !!! failed kinematics etc.: set weight to zero instance%weight = zero !!! Maybe we want to process and keep the event nevertheless if (instance%keep_failed_events ()) then do i = 1, size (instance%term) associate (term => instance%term(i)) if (term%active) then call term%evaluate_event_data () end if end associate end do ! 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 for the term instance with index [[i_term]] and a phase space point set with index [[i_phs]]. In addition, for the real emission, each term instance corresponds to one emitter. There is the possibility to supply an external $\alpha_s$ as well as an external scale to override the scale set in the Sindarin, e.g. for POWHEG matching. <>= procedure :: compute_sqme_rad => process_instance_compute_sqme_rad <>= module subroutine process_instance_compute_sqme_rad (instance, & i_term, i_phs, is_subtraction, alpha_s_external, scale_forced) 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 real(default), intent(in), allocatable, optional :: scale_forced end subroutine process_instance_compute_sqme_rad <>= module subroutine process_instance_compute_sqme_rad (instance, & i_term, i_phs, is_subtraction, alpha_s_external, scale_forced) 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 real(default), intent(in), allocatable, optional :: scale_forced class(prc_core_t), pointer :: core integer :: i_real_fin logical :: has_pdfs has_pdfs = instance%process%pcm_contains_pdfs () select type (pcm_work => instance%pcm_work) type is (pcm_nlo_workspace_t) if (allocated(pcm_work%real_sub%sqme_real_arr)) then pcm_work%real_sub%sqme_real_arr = zero end if end select if (debug_on) call msg_debug2 (D_PROCESS_INTEGRATION, "process_instance_compute_sqme_rad") select type (pcm_work => instance%pcm_work) type is (pcm_nlo_workspace_t) associate (term => instance%term(i_term), kin => instance%kin(i_term)) core => instance%process%get_core_term (i_term) if (is_subtraction) then call pcm_work%set_subtraction_event () else call pcm_work%set_radiation_event () end if call term%int_hard%set_momenta (pcm_work%get_momenta & (term%pcm, 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)) then call term%set_alpha_qcd_forced (alpha_s_external) end if call term%compute_eff_kinematics () call term%evaluate_expressions & (instance%process%get_beam_config (), scale_forced) call term%evaluate_interaction (core, kin) call term%evaluate_trace (kin) if (term%is_subtraction ()) then call term%set_sf_factors (kin, has_pdfs) select type (pcm => instance%pcm) type is (pcm_nlo_t) if (char (pcm%settings%nlo_correction_type) == "QCD" .or. & char (pcm%settings%nlo_correction_type) == "Full") & call term%evaluate_color_correlations (core) if (char (pcm%settings%nlo_correction_type) == "EW" .or. & char (pcm%settings%nlo_correction_type) == "Full") & call term%evaluate_charge_correlations (core) end select call term%evaluate_spin_correlations (core) end if i_real_fin = instance%process%get_associated_real_fin (1) if (term%config%i_component /= i_real_fin) & call term%apply_fks (kin, core%get_alpha_s (term%core_state), & core%get_alpha_qed (term%core_state)) 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. <>= procedure :: normalize_weight => process_instance_normalize_weight <>= module subroutine process_instance_normalize_weight (instance) class(process_instance_t), intent(inout) :: instance end subroutine process_instance_normalize_weight <>= module 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]]. <>= procedure :: evaluate_sqme => process_instance_evaluate_sqme <>= module 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 end subroutine process_instance_evaluate_sqme <>= module 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]]. <>= procedure :: recover => process_instance_recover <>= module 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 end subroutine process_instance_recover <>= module 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, recover 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) recover = instance%pcm_work%is_nlo () if (recover_phs) then call instance%recover_mcpar (i_term) call instance%recover_beam_momenta (i_term) call instance%compute_seed_kinematics & (recover = recover, skip_term = i_term) call instance%compute_hard_kinematics & (recover = recover, skip_term = 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 (recover) 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]]. <>= procedure :: evaluate => process_instance_evaluate <>= module 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 end subroutine process_instance_evaluate <>= module 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. <>= procedure :: is_valid => process_instance_is_valid <>= module function process_instance_is_valid (sampler) result (valid) class(process_instance_t), intent(in) :: sampler logical :: valid end function process_instance_is_valid <>= module 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.. <>= procedure :: append_after_hook => process_instance_append_after_hook <>= module 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 end subroutine process_instance_append_after_hook <>= module 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. <>= procedure :: evaluate_after_hook => process_instance_evaluate_after_hook <>= module subroutine process_instance_evaluate_after_hook (sampler) class(process_instance_t), intent(in) :: sampler end subroutine process_instance_evaluate_after_hook <>= module 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. <>= procedure :: rebuild => process_instance_rebuild <>= module 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 end subroutine process_instance_rebuild <>= module 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. <>= procedure :: fetch => process_instance_fetch <>= module 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 end subroutine process_instance_fetch <>= module 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%kin(i_term_base)) 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. <>= procedure :: init_simulation => process_instance_init_simulation procedure :: final_simulation => process_instance_final_simulation <>= module 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 end subroutine process_instance_init_simulation module subroutine process_instance_final_simulation (instance, i_mci) class(process_instance_t), intent(inout) :: instance integer, intent(in) :: i_mci end subroutine process_instance_final_simulation <>= module 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 module 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. <>= procedure :: get_mcpar => process_instance_get_mcpar <>= module 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 end subroutine process_instance_get_mcpar <>= module 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%kin(i)%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. <>= procedure :: has_evaluated_trace => process_instance_has_evaluated_trace <>= module function process_instance_has_evaluated_trace & (instance) result (flag) class(process_instance_t), intent(in) :: instance logical :: flag end function process_instance_has_evaluated_trace <>= module 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. <>= procedure :: is_complete_event => process_instance_is_complete_event <>= module function process_instance_is_complete_event (instance) result (flag) class(process_instance_t), intent(in) :: instance logical :: flag end function process_instance_is_complete_event <>= module 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]]). <>= procedure :: select_i_term => process_instance_select_i_term <>= module function process_instance_select_i_term (instance) result (i_term) integer :: i_term class(process_instance_t), intent(in) :: instance end function process_instance_select_i_term <>= module 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. <>= procedure :: get_beam_int_ptr => process_instance_get_beam_int_ptr <>= module function process_instance_get_beam_int_ptr (instance) result (ptr) class(process_instance_t), intent(in), target :: instance type(interaction_t), pointer :: ptr end function process_instance_get_beam_int_ptr <>= module 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. <>= 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 <>= module 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 end function process_instance_get_trace_int_ptr module 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 end function process_instance_get_matrix_int_ptr module 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 end function process_instance_get_flows_int_ptr <>= module 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 module 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 module 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. <>= procedure :: get_state_flv => process_instance_get_state_flv <>= module 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 end function process_instance_get_state_flv <>= module 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. <>= procedure :: get_isolated_state_ptr => & process_instance_get_isolated_state_ptr procedure :: get_connected_state_ptr => & process_instance_get_connected_state_ptr <>= module 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 end function process_instance_get_isolated_state_ptr module 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 end function process_instance_get_connected_state_ptr <>= module 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 module 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. <>= procedure :: get_beam_index => process_instance_get_beam_index procedure :: get_in_index => process_instance_get_in_index <>= module 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 end subroutine process_instance_get_beam_index module 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 end subroutine process_instance_get_in_index <>= module 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 module 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. [[n_dropped]] is a number that can be nonzero when a weighted event has been generated, dropping events with zero weight (failed cuts) on the fly. If [[i_term]] is provided for [[get_sqme]], we take the first matrix element as we also set the first matrix element with [[set_only_matrix_element]] when computing the real, the dglap or the virtual contribution. <>= procedure :: get_sqme => process_instance_get_sqme procedure :: get_weight => process_instance_get_weight procedure :: get_excess => process_instance_get_excess procedure :: get_n_dropped => process_instance_get_n_dropped <>= module 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 end function process_instance_get_sqme module function process_instance_get_weight (instance) result (weight) real(default) :: weight class(process_instance_t), intent(in) :: instance end function process_instance_get_weight module function process_instance_get_excess (instance) result (excess) real(default) :: excess class(process_instance_t), intent(in) :: instance end function process_instance_get_excess module function process_instance_get_n_dropped (instance) result (n_dropped) integer :: n_dropped class(process_instance_t), intent(in) :: instance end function process_instance_get_n_dropped <>= module 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 module 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 module 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 module function process_instance_get_n_dropped (instance) result (n_dropped) integer :: n_dropped class(process_instance_t), intent(in) :: instance if (instance%evaluation_status >= STAT_EVENT_COMPLETE) then n_dropped = instance%n_dropped else n_dropped = 0 end if end function process_instance_get_n_dropped @ %def process_instance_get_sqme @ %def process_instance_get_weight @ %def process_instance_get_excess @ %def process_instance_get_n_dropped @ Return the currently selected MCI channel. <>= procedure :: get_channel => process_instance_get_channel <>= module function process_instance_get_channel (instance) result (channel) integer :: channel class(process_instance_t), intent(in) :: instance end function process_instance_get_channel <>= module 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 @ <>= procedure :: set_fac_scale => process_instance_set_fac_scale <>= module subroutine process_instance_set_fac_scale (instance, fac_scale) class(process_instance_t), intent(inout) :: instance real(default), intent(in) :: fac_scale end subroutine process_instance_set_fac_scale <>= module 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. <>= procedure :: get_fac_scale => process_instance_get_fac_scale procedure :: get_alpha_s => process_instance_get_alpha_s <>= module 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 end function process_instance_get_fac_scale module 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 end function process_instance_get_alpha_s <>= module 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 module 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 @ <>= procedure :: get_qcd => process_instance_get_qcd <>= module function process_instance_get_qcd (process_instance) result (qcd) type(qcd_t) :: qcd class(process_instance_t), intent(in) :: process_instance end function process_instance_get_qcd <>= module function process_instance_get_qcd (process_instance) result (qcd) type(qcd_t) :: qcd class(process_instance_t), intent(in) :: process_instance qcd = process_instance%process%get_qcd () end function process_instance_get_qcd @ %def process_instance_get_qcd @ Counter. <>= procedure :: reset_counter => process_instance_reset_counter procedure :: record_call => process_instance_record_call procedure :: get_counter => process_instance_get_counter <>= module subroutine process_instance_reset_counter (process_instance) class(process_instance_t), intent(inout) :: process_instance end subroutine process_instance_reset_counter module subroutine process_instance_record_call (process_instance) class(process_instance_t), intent(inout) :: process_instance end subroutine process_instance_record_call pure module function process_instance_get_counter & (process_instance) result (counter) class(process_instance_t), intent(in) :: process_instance type(process_counter_t) :: counter end function process_instance_get_counter <>= module 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 module 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 module 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. <>= procedure :: get_actual_calls_total => process_instance_get_actual_calls_total <>= pure module function process_instance_get_actual_calls_total & (process_instance) result (n) class(process_instance_t), intent(in) :: process_instance integer :: n end function process_instance_get_actual_calls_total <>= pure module 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 @ <>= procedure :: reset_matrix_elements => process_instance_reset_matrix_elements <>= module subroutine process_instance_reset_matrix_elements (instance) class(process_instance_t), intent(inout) :: instance end subroutine process_instance_reset_matrix_elements <>= module 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 @ <>= procedure :: get_test_phase_space_point & => process_instance_get_test_phase_space_point <>= module 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 end subroutine process_instance_get_test_phase_space_point <>= module 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), kin => instance%kin(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 & (kin, instance%mci_work(i_component), 1, success) call kin%evaluate_radiation_kinematics & (instance%mci_work(instance%i_mci)%get_x_process ()) call term%compute_hard_kinematics (kin, 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 @ <>= procedure :: get_p_hard => process_instance_get_p_hard <>= pure module 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 end function process_instance_get_p_hard <>= pure module 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 @ <>= procedure :: get_first_active_i_term => & process_instance_get_first_active_i_term <>= module function process_instance_get_first_active_i_term & (instance) result (i_term) integer :: i_term class(process_instance_t), intent(in) :: instance end function process_instance_get_first_active_i_term <>= module 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 @ <>= procedure :: get_real_of_mci => process_instance_get_real_of_mci <>= module function process_instance_get_real_of_mci (instance) result (i_real) integer :: i_real class(process_instance_t), intent(in) :: instance end function process_instance_get_real_of_mci <>= module function process_instance_get_real_of_mci (instance) result (i_real) integer :: i_real class(process_instance_t), intent(in) :: instance select type (pcm_work => instance%pcm_work) type is (pcm_nlo_workspace_t) i_real = pcm_work%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 @ <>= procedure :: get_connected_states => process_instance_get_connected_states <>= module 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 end function process_instance_get_connected_states <>= module 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 <>= procedure :: get_sqrts => process_instance_get_sqrts <>= module function process_instance_get_sqrts (instance) result (sqrts) class(process_instance_t), intent(in) :: instance real(default) :: sqrts end function process_instance_get_sqrts <>= module 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 <>= procedure :: get_polarization => process_instance_get_polarization <>= module function process_instance_get_polarization (instance) result (pol) class(process_instance_t), intent(in) :: instance real(default), dimension(:), allocatable :: pol end function process_instance_get_polarization <>= module function process_instance_get_polarization (instance) result (pol) class(process_instance_t), intent(in) :: instance real(default), dimension(:), allocatable :: pol pol = instance%process%get_polarization () end function process_instance_get_polarization @ %def process_instance_get_polarization @ Get the beam spectrum <>= procedure :: get_beam_file => process_instance_get_beam_file <>= module function process_instance_get_beam_file (instance) result (file) class(process_instance_t), intent(in) :: instance type(string_t) :: file end function process_instance_get_beam_file <>= module 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 <>= procedure :: get_process_name => process_instance_get_process_name <>= module function process_instance_get_process_name (instance) result (name) class(process_instance_t), intent(in) :: instance type(string_t) :: name end function process_instance_get_process_name <>= module 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. <>= procedure :: get_trace => process_instance_get_trace procedure :: set_trace => process_instance_set_trace <>= module 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 end subroutine process_instance_get_trace module subroutine process_instance_set_trace & (instance, pset, i_term, recover_beams, check_match, success) 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 logical, intent(out), optional :: success end subroutine process_instance_set_trace <>= module 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 module subroutine process_instance_set_trace & (instance, pset, i_term, recover_beams, check_match, success) 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 logical, intent(out), optional :: success 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), & success = success) 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. <>= procedure :: set_alpha_qcd_forced => process_instance_set_alpha_qcd_forced <>= module 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 end subroutine process_instance_set_alpha_qcd_forced <>= module 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 @ <>= procedure :: has_nlo_component => process_instance_has_nlo_component <>= module function process_instance_has_nlo_component (instance) result (nlo) class(process_instance_t), intent(in) :: instance logical :: nlo end function process_instance_has_nlo_component <>= module 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 @ <>= procedure :: keep_failed_events => process_instance_keep_failed_events <>= module function process_instance_keep_failed_events (instance) result (keep) logical :: keep class(process_instance_t), intent(in) :: instance end function process_instance_keep_failed_events <>= module 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 @ <>= procedure :: get_term_indices => process_instance_get_term_indices <>= module 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 end function process_instance_get_term_indices <>= module 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 @ <>= procedure :: get_boost_to_lab => process_instance_get_boost_to_lab <>= module 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 end function process_instance_get_boost_to_lab <>= module 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%kin(i_term)%get_boost_to_lab () end function process_instance_get_boost_to_lab @ %def process_instance_get_boost_to_lab @ <>= procedure :: get_boost_to_cms => process_instance_get_boost_to_cms <>= module 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 end function process_instance_get_boost_to_cms <>= module 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%kin(i_term)%get_boost_to_cms () end function process_instance_get_boost_to_cms @ %def process_instance_get_boost_to_cms @ <>= procedure :: lab_is_cm => process_instance_lab_is_cm <>= module function process_instance_lab_is_cm & (instance, i_term) result (lab_is_cm) logical :: lab_is_cm class(process_instance_t), intent(in) :: instance integer, intent(in) :: i_term end function process_instance_lab_is_cm <>= module function process_instance_lab_is_cm & (instance, i_term) result (lab_is_cm) logical :: lab_is_cm class(process_instance_t), intent(in) :: instance integer, intent(in) :: i_term lab_is_cm = instance%kin(i_term)%phs%lab_is_cm () end function process_instance_lab_is_cm @ %def process_instance_lab_is_cm @ 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. <>= public :: pacify <>= interface pacify module procedure pacify_process_instance end interface pacify <>= module subroutine pacify_process_instance (instance) type(process_instance_t), intent(inout) :: instance end subroutine pacify_process_instance <>= module subroutine pacify_process_instance (instance) type(process_instance_t), intent(inout) :: instance integer :: i do i = 1, size (instance%kin) call pacify (instance%kin(i)%phs) end do end subroutine pacify_process_instance @ %def pacify @ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{Unit tests} Test module, followed by the corresponding implementation module. <<[[processes_ut.f90]]>>= <> module processes_ut use unit_tests use processes_uti <> <> <> contains <> end module processes_ut @ %def processes_ut @ <<[[processes_uti.f90]]>>= <> module processes_uti <> <> 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 models 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 pdf, only: pdf_data_t 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 <> <> <> <> contains <> <> end module processes_uti @ %def processes_uti @ API: driver for the unit tests below. <>= public :: processes_test <>= subroutine processes_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> end subroutine processes_test @ %def processes_test \subsubsection{Write an empty process object} The most trivial test is to write an uninitialized process object. <>= call test (processes_1, "processes_1", & "write an empty process object", & u, results) <>= public :: processes_1 <>= 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. <>= call test (processes_2, "processes_2", & "initialize a simple process object", & u, results) <>= public :: processes_2 <>= subroutine processes_2 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), target :: 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 call os_data%init () call prc_test_create_library (libname, lib) write (u, "(A)") "* Initialize a process object" write (u, "(A)") call model%init_test () allocate (process) call process%init (procname, lib, os_data, model) call process%set_run_id (var_str ("run_2")) call process%setup_test_cores () allocate (phs_test_config_t :: phs_config_template) call process%init_components (phs_config_template) call process%setup_mci (dispatch_mci_empty) call process%write (.false., u) write (u, "(A)") write (u, "(A)") "* Cleanup" call process%final () deallocate (process) call model%final () write (u, "(A)") write (u, "(A)") "* Test output end: processes_2" end subroutine processes_2 @ %def processes_2 @ Trivial for testing: do not allocate the MCI record. <>= subroutine dispatch_mci_empty (mci, var_list, process_id, is_nlo) class(mci_t), allocatable, intent(out) :: mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id logical, intent(in), optional :: is_nlo end subroutine dispatch_mci_empty @ %def dispatch_mci_empty @ \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. <>= call test (processes_3, "processes_3", & "retrieve a trivial matrix element", & u, results) <>= public :: processes_3 <>= subroutine processes_3 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), target :: model type(process_t), allocatable :: process 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 call os_data%init () call prc_test_create_library (libname, lib) call model%init_test () allocate (process) call process%init (procname, lib, os_data, model) call process%setup_test_cores () allocate (phs_test_config_t :: phs_config_template) call process%init_components (phs_config_template) call process%setup_mci (dispatch_mci_test3) 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) call model%final () write (u, "(A)") write (u, "(A)") "* Test output end: processes_3" end subroutine processes_3 @ %def processes_3 @ MCI record with some contents. <>= subroutine dispatch_mci_test3 (mci, var_list, process_id, is_nlo) class(mci_t), allocatable, intent(out) :: mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id logical, intent(in), optional :: is_nlo allocate (mci_test_t :: mci) select type (mci) type is (mci_test_t) call mci%set_dimensions (2, 2) call mci%set_divisions (100) end select end subroutine dispatch_mci_test3 @ %def dispatch_mci_test3 @ \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. <>= call test (processes_4, "processes_4", & "create and fill a process instance (partonic event)", & u, results) <>= public :: processes_4 <>= subroutine processes_4 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), target :: model type(process_t), allocatable, target :: process 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 call os_data%init () call prc_test_create_library (libname, lib) call reset_interaction_counter () call model%init_test () allocate (process) call process%init (procname, lib, os_data, model) call process%setup_test_cores () allocate (phs_test_config_t :: phs_config_template) call process%init_components (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 (dispatch_mci_empty) 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) call model%final () 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. <>= call test (processes_7, "processes_7", & "process configuration with structure functions", & u, results) <>= public :: processes_7 <>= subroutine processes_7 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), target :: model type(process_t), allocatable, target :: process 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 call os_data%init () call prc_test_create_library (libname, lib) call model%init_test () allocate (process) call process%init (procname, lib, os_data, model) call process%setup_test_cores () allocate (phs_test_config_t :: phs_config_template) call process%init_components (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) call data%init (process%get_model_ptr (), 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 (dispatch_mci_empty) call process%write (.false., u) write (u, "(A)") write (u, "(A)") "* Cleanup" call process%final () deallocate (process) call model%final () 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. <>= call test (processes_8, "processes_8", & "process evaluation with structure functions", & u, results) <>= public :: processes_8 <>= subroutine processes_8 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), target :: model type(process_t), allocatable, target :: process 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 call os_data%init () call prc_test_create_library (libname, lib) call reset_interaction_counter () call model%init_test () allocate (process) call process%init (procname, lib, os_data, model) call process%setup_test_cores () allocate (phs_test_config_t :: phs_config_template) call process%init_components (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) call data%init (process%get_model_ptr (), 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 (dispatch_mci_empty) 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 pacify (pset) 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) call model%final () 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. <>= call test (processes_9, "processes_9", & "multichannel kinematics and structure functions", & u, results) <>= public :: processes_9 <>= subroutine processes_9 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), target :: model type(process_t), allocatable, target :: process 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 call os_data%init () call prc_test_create_library (libname, lib) call reset_interaction_counter () call model%init_test () allocate (process) call process%init (procname, lib, os_data, model) call process%setup_test_cores () allocate (phs_test_config_t :: phs_config_template) call process%init_components (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) call data%init (process%get_model_ptr (), 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 (dispatch_mci_empty) 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) call model%final () 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. <>= call test (processes_10, "processes_10", & "event generation", & u, results) <>= public :: processes_10 <>= subroutine processes_10 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), target :: model type(process_t), allocatable, target :: process 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 call os_data%init () call prc_test_create_library (libname, lib) call reset_interaction_counter () call model%init_test () allocate (process) call process%init (procname, lib, os_data, model) call process%setup_test_cores () allocate (phs_test_config_t :: phs_config_template) call process%init_components (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 (dispatch_mci_test10) 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) call model%final () write (u, "(A)") write (u, "(A)") "* Test output end: processes_10" end subroutine processes_10 @ %def processes_10 @ MCI record with some contents. <>= subroutine dispatch_mci_test10 (mci, var_list, process_id, is_nlo) class(mci_t), allocatable, intent(out) :: mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id logical, intent(in), optional :: is_nlo allocate (mci_test_t :: mci) select type (mci) type is (mci_test_t); call mci%set_divisions (100) end select end subroutine dispatch_mci_test10 @ %def dispatch_mci_test10 @ \subsubsection{Integration} Activate the MC integrator for the process object and use it to integrate over phase space. <>= call test (processes_11, "processes_11", & "integration", & u, results) <>= public :: processes_11 <>= subroutine processes_11 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), target :: 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 call os_data%init () call prc_test_create_library (libname, lib) call reset_interaction_counter () call model%init_test () allocate (process) call process%init (procname, lib, os_data, model) call process%setup_test_cores () allocate (phs_test_config_t :: phs_config_template) call process%init_components (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 (dispatch_mci_test10) 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%kin(1)%phs_factor write (u, "(A)") write (u, "(A)") "* Cleanup" call process_instance%final () deallocate (process_instance) call process%final () deallocate (process) call model%final () 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. <>= public :: prepare_test_process <>= subroutine prepare_test_process & (process, process_instance, model, var_list, run_id) 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(var_list_t), intent(inout), optional :: var_list type(string_t), intent(in), optional :: run_id type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), allocatable, target :: process_model class(mci_t), pointer :: mci class(phs_config_t), allocatable :: phs_config_template real(default) :: sqrts libname = "processes_test" procname = libname call os_data%init () 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, lib, os_data, process_model, var_list) if (present (run_id)) call process%set_run_id (run_id) call process%setup_test_cores () allocate (phs_test_config_t :: phs_config_template) call process%init_components (phs_config_template) sqrts = 1000 call process%setup_beams_sqrts (sqrts, i_core = 1) call process%configure_phs () call process%setup_mci (dispatch_mci_test10) 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%reset_library_ptr () ! avoid dangling pointer call process_model%final () 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. <>= public :: cleanup_test_process <>= 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. <>= call test (processes_12, "processes_12", & "event post-processing", & u, results) <>= public :: processes_12 <>= 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, & run_id = var_str ("run_12")) 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. <>= call test (processes_13, "processes_13", & "colored interaction", & u, results) <>= public :: processes_13 <>= 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 () call model%init_sm_test () 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 <>= call test (processes_14, "processes_14", & "process configuration and MD5 sum", & u, results) <>= public :: processes_14 <>= subroutine processes_14 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), target :: model type(process_t), allocatable, target :: process 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 call os_data%init () call prc_test_create_library (libname, lib) call lib%compute_md5sum () call model%init_test () allocate (process) call process%init (procname, lib, os_data, model) call process%setup_test_cores () allocate (phs_test_config_t :: phs_config_template) call process%init_components (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) call data%init (process%get_model_ptr (), 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 (dispatch_mci_empty) call process%compute_md5sum () call process%write (.false., u) write (u, "(A)") write (u, "(A)") "* Cleanup" call process%final () deallocate (process) call model%final () 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. <>= call test (processes_15, "processes_15", & "decay process", & u, results) <>= public :: processes_15 <>= subroutine processes_15 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), target :: model type(process_t), allocatable, target :: process 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 call os_data%init () call prc_test_create_library (libname, lib, scattering = .false., & decay = .true.) 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, lib, os_data, model) call process%setup_test_cores () allocate (phs_single_config_t :: phs_config_template) call process%init_components (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 (dispatch_mci_empty) 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) call model%final () 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. <>= call test (processes_16, "processes_16", & "decay integration", & u, results) <>= public :: processes_16 <>= subroutine processes_16 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), target :: model type(process_t), allocatable, target :: process 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 call os_data%init () call prc_test_create_library (libname, lib, scattering = .false., & decay = .true.) call reset_interaction_counter () 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, lib, os_data, model) call process%setup_test_cores () allocate (phs_single_config_t :: phs_config_template) call process%init_components (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 (dispatch_mci_test_midpoint) 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%kin(1)%phs_factor write (u, "(A)") write (u, "(A)") "* Cleanup" call process_instance%final () deallocate (process_instance) call process%final () deallocate (process) call model%final () write (u, "(A)") write (u, "(A)") "* Test output end: processes_16" end subroutine processes_16 @ %def processes_16 @ MCI record prepared for midpoint integrator. <>= subroutine dispatch_mci_test_midpoint (mci, var_list, process_id, is_nlo) class(mci_t), allocatable, intent(out) :: mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id logical, intent(in), optional :: is_nlo allocate (mci_midpoint_t :: mci) end subroutine dispatch_mci_test_midpoint @ %def dispatch_mci_test_midpoint @ \subsubsection{Decay Process Evaluation} Initialize an evaluate a decay process for a moving particle. <>= call test (processes_17, "processes_17", & "decay of moving particle", & u, results) <>= public :: processes_17 <>= subroutine processes_17 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data type(model_t), target :: model type(process_t), allocatable, target :: process 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 call os_data%init () call prc_test_create_library (libname, lib, scattering = .false., & decay = .true.) write (u, "(A)") "* Initialize a process object" write (u, "(A)") 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, lib, os_data, model) call process%setup_test_cores () allocate (phs_single_config_t :: phs_config_template) call process%init_components (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 (dispatch_mci_empty) 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]) call flv_beam%init (25, process%get_model_ptr ()) 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) call model%final () 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. <>= call test (processes_18, "processes_18", & "extract resonance history set", & u, results) <>= public :: processes_18 <>= 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 () call syntax_phs_forest_init () model_name = "SM" model => null () call prepare_model (model, model_name, vars) write (u, "(A)") "* Initialize a process library with one process" write (u, "(A)") select type (model) class is (model_t) call prepare_resonance_test_library (lib, libname, procname, model, os_data, u) end select write (u, "(A)") write (u, "(A)") "* Initialize a process object with phase space" allocate (process) select type (model) class is (model_t) call prepare_resonance_test_process (process, lib, procname, model, os_data) end select 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 model%final () deallocate (model) 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. <>= 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 type(model_t), intent(in), target :: 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. <>= 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 type(model_t), intent(in), target :: model type(os_data_t), intent(in) :: os_data class(phs_config_t), allocatable :: phs_config_template real(default) :: sqrts call process%init (procname, lib, os_data, model) allocate (phs_wood_config_t :: phs_config_template) call process%init_components (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 (dispatch_mci_none) call process%setup_terms () end subroutine prepare_resonance_test_process @ %def prepare_resonance_test_process @ MCI record prepared for the none (dummy) integrator. <>= subroutine dispatch_mci_none (mci, var_list, process_id, is_nlo) class(mci_t), allocatable, intent(out) :: mci type(var_list_t), intent(in) :: var_list type(string_t), intent(in) :: process_id logical, intent(in), optional :: is_nlo allocate (mci_none_t :: mci) end subroutine dispatch_mci_none @ %def dispatch_mci_none @ \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. <>= 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 @ <>= subroutine process_instance_hook_test_init (hook, var_list, instance, pdf_data) 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 type(pdf_data_t), intent(in), optional :: pdf_data 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 @ <>= call test (processes_19, "processes_19", & "add trivial hooks to a process instance ", & u, results) <>= public :: processes_19 <>= subroutine processes_19 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(string_t) :: libname type(string_t) :: procname type(os_data_t) :: os_data class(model_data_t), pointer :: model type(process_t), allocatable, target :: process 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]]>>= <> module process_stacks <> <> use variables use process <> <> <> interface <> end interface end module process_stacks @ %def process_stacks @ <<[[process_stacks_sub.f90]]>>= <> submodule (process_stacks) process_stacks_s use io_units use format_utils, only: write_separator use diagnostics use observables implicit none contains <> end submodule process_stacks_s @ %def process_stacks_s @ \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. <>= public :: process_entry_t <>= 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. <>= public :: process_stack_t <>= 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 <> 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. <>= procedure :: clear => process_stack_clear <>= module subroutine process_stack_clear (stack) class(process_stack_t), intent(inout) :: stack end subroutine process_stack_clear <>= module 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. <>= procedure :: final => process_stack_final <>= module subroutine process_stack_final (object) class(process_stack_t), intent(inout) :: object end subroutine process_stack_final <>= module 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. <>= procedure :: write => process_stack_write <>= recursive module subroutine process_stack_write (object, unit, pacify) class(process_stack_t), intent(in) :: object integer, intent(in), optional :: unit logical, intent(in), optional :: pacify end subroutine process_stack_write <>= recursive module 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. <>= procedure :: write_var_list => process_stack_write_var_list <>= module subroutine process_stack_write_var_list (object, unit) class(process_stack_t), intent(in) :: object integer, intent(in), optional :: unit end subroutine process_stack_write_var_list <>= module 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 object%var_list%write (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. <>= procedure :: show => process_stack_show <>= recursive module subroutine process_stack_show (object, unit, fifo) class(process_stack_t), intent(in) :: object integer, intent(in), optional :: unit logical, intent(in), optional :: fifo end subroutine process_stack_show <>= recursive module 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. <>= procedure :: link => process_stack_link <>= module 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 end subroutine process_stack_link <>= module 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. <>= procedure :: init_var_list => process_stack_init_var_list <>= module 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 end subroutine process_stack_init_var_list <>= module 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. <>= procedure :: link_var_list => process_stack_link_var_list <>= module 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 end subroutine process_stack_link_var_list <>= module 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. <>= procedure :: push => process_stack_push <>= module subroutine process_stack_push (stack, process) class(process_stack_t), intent(inout) :: stack type(process_entry_t), intent(inout), pointer :: process end subroutine process_stack_push <>= module 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. <>= procedure :: pop_last => process_stack_pop_last <>= module subroutine process_stack_pop_last (stack, process) class(process_stack_t), intent(inout) :: stack type(process_entry_t), intent(inout), pointer :: process end subroutine process_stack_pop_last <>= module 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. <>= procedure :: init_result_vars => process_stack_init_result_vars <>= module subroutine process_stack_init_result_vars (stack, id) class(process_stack_t), intent(inout) :: stack type(string_t), intent(in) :: id end subroutine process_stack_init_result_vars <>= module 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.) <>= procedure :: fill_result_vars => process_stack_fill_result_vars <>= module subroutine process_stack_fill_result_vars (stack, id) class(process_stack_t), intent(inout) :: stack type(string_t), intent(in) :: id end subroutine process_stack_fill_result_vars <>= module 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. <>= procedure :: update_result_vars => process_stack_update_result_vars <>= module 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 end subroutine process_stack_update_result_vars <>= module 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. <>= procedure :: exists => process_stack_exists <>= module function process_stack_exists (stack, id) result (flag) class(process_stack_t), intent(in) :: stack type(string_t), intent(in) :: id logical :: flag end function process_stack_exists <>= module 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. <>= procedure :: get_process_ptr => process_stack_get_process_ptr <>= recursive module 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 end function process_stack_get_process_ptr <>= recursive module 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]]>>= <> module process_stacks_ut use unit_tests use process_stacks_uti <> <> contains <> end module process_stacks_ut @ %def process_stacks_ut @ <<[[process_stacks_uti.f90]]>>= <> module process_stacks_uti <> use os_interface use sm_qcd use models use model_data use variables, only: var_list_t 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 <> <> contains <> end module process_stacks_uti @ %def process_stacks_uti @ API: driver for the unit tests below. <>= public :: process_stacks_test <>= subroutine process_stacks_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> 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. <>= call test (process_stacks_1, "process_stacks_1", & "write an empty process stack", & u, results) <>= public :: process_stacks_1 <>= 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. <>= call test (process_stacks_2, "process_stacks_2", & "fill a process stack", & u, results) <>= public :: process_stacks_2 <>= 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(os_data_t) :: os_data type(model_t), target :: model type(var_list_t) :: var_list 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 () call prc_test_create_library (libname, lib) call model%init_test () call var_list%append_string (var_str ("$run_id")) call var_list%append_log (var_str ("?alphas_is_fixed"), .true.) call var_list%append_int (var_str ("seed"), 0) allocate (process) call var_list%set_string & (var_str ("$run_id"), var_str ("run1"), is_known=.true.) call process%init (procname, lib, os_data, model, var_list) call stack%push (process) allocate (process) call var_list%set_string & (var_str ("$run_id"), var_str ("run2"), is_known=.true.) call process%init (procname, lib, os_data, model, var_list) call stack%push (process) call stack%write (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_2" end subroutine process_stacks_2 @ %def process_stacks_2 @ \subsubsection{Fill a process stack} Fill a process stack with two (identical) processes. <>= call test (process_stacks_3, "process_stacks_3", & "process variables", & u, results) <>= public :: process_stacks_3 <>= subroutine process_stacks_3 (u) integer, intent(in) :: u type(process_stack_t) :: stack type(model_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. <>= call test (process_stacks_4, "process_stacks_4", & "linked stacks", & u, results) <>= public :: process_stacks_4 <>= subroutine process_stacks_4 (u) integer, intent(in) :: u type(process_library_t), target :: lib type(process_stack_t), target :: stack1, stack2 type(model_t), target :: model type(string_t) :: libname type(string_t) :: procname1, procname2 type(os_data_t) :: os_data 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" procname1 = "process_stacks_4a" procname2 = "process_stacks_4b" call os_data%init () write (u, "(A)") "* Initialize first process" write (u, "(A)") call prc_test_create_library (procname1, lib) call model%init_test () allocate (process) call process%init (procname1, lib, os_data, model) call stack1%push (process) write (u, "(A)") "* Initialize second process" write (u, "(A)") call stack2%link (stack1) call prc_test_create_library (procname2, lib) allocate (process) call process%init (procname2, lib, os_data, 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 () call model%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 8839) +++ trunk/src/particles/particles.nw (revision 8840) @@ -1,9688 +1,9692 @@ %% -*- 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]]>>= <> module su_algebra <> <> <> interface <> end interface end module su_algebra @ %def su_algebra @ <<[[su_algebra_sub.f90]]>>= <> submodule (su_algebra) su_algebra_s use physics_defs, only: SCALAR, SPINOR, VECTOR, VECTORSPINOR, TENSOR implicit none contains <> end submodule su_algebra_s @ %def su_algbra_s @ \subsection{$su(N)$ fundamental representation} The dimension of the basis for a given spin type. consecutively, starting at [[SCALAR=1]]. <>= public :: algebra_dimension <>= module function algebra_dimension (s) result (n) integer :: n integer, intent(in) :: s end function algebra_dimension <>= module 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. <>= public :: fundamental_dimension <>= module function fundamental_dimension (s) result (d) integer :: d integer, intent(in) :: s end function fundamental_dimension <>= module 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. <>= public :: helicity_value <>= module function helicity_value (s, i) result (h) integer :: h integer, intent(in) :: s, i end function helicity_value <>= module 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. <>= public :: helicity_index <>= module function helicity_index (s, h) result (i) integer, intent(in) :: s, h integer :: i end function helicity_index <>= module 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]]. <>= public :: is_cartan_generator <>= elemental module function is_cartan_generator (s, i) result (cartan) logical :: cartan integer, intent(in) :: s, i end function is_cartan_generator <>= elemental module 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. <>= public :: cartan_index <>= elemental module function cartan_index (s, k) result (ci) integer :: ci integer, intent(in) :: s, k end function cartan_index <>= elemental module 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. <>= public :: cartan_element <>= module function cartan_element (s, h) result (a) real(default), dimension(:), allocatable :: a integer, intent(in) :: s, h end function cartan_element <>= module 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. <>= public :: cartan_coeff <>= module function cartan_coeff (s, rd) result (a) real(default), dimension(:), allocatable :: a integer, intent(in) :: s real(default), dimension(:), intent(in) :: rd end function cartan_coeff <>= module 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. <>= public :: root_index <>= module function root_index (s, h1, h2, r) result (ai) integer :: ai integer, intent(in) :: s, h1, h2 logical :: r end function root_index <>= module 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. <>= public :: root_helicity <>= module subroutine root_helicity (s, i, h1, h2, r) integer, intent(in) :: s, i integer, intent(out) :: h1, h2 logical, intent(out) :: r end subroutine root_helicity <>= module 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]]>>= <> module su_algebra_ut use unit_tests use su_algebra_uti <> <> contains <> end module su_algebra_ut @ %def su_algebra_ut @ <<[[su_algebra_uti.f90]]>>= <> module su_algebra_uti <> use physics_defs, only: SCALAR, SPINOR, VECTOR, VECTORSPINOR, TENSOR use su_algebra <> <> contains <> end module su_algebra_uti @ %def su_algebra_ut @ API: driver for the unit tests below. <>= public :: su_algebra_test <>= subroutine su_algebra_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> end subroutine su_algebra_test @ %def su_algebra_test @ \subsubsection{Generator Ordering} Show the position of Cartan generators in the sequence of basis generators. <>= call test (su_algebra_1, "su_algebra_1", & "generator ordering", & u, results) <>= public :: su_algebra_1 <>= 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. <>= call test (su_algebra_2, "su_algebra_2", & "Cartan generator representation", & u, results) <>= public :: su_algebra_2 <>= 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. <>= call test (su_algebra_3, "su_algebra_3", & "Cartan generator mapping", & u, results) <>= public :: su_algebra_3 <>= 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. <>= call test (su_algebra_4, "su_algebra_4", & "Root-helicity mapping", & u, results) <>= public :: su_algebra_4 <>= 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]]>>= <> module bloch_vectors <> use physics_defs, only: UNKNOWN <> <> <> interface <> end interface end module bloch_vectors @ %def bloch_vectors @ <<[[bloch_vectors_sub.f90]]>>= <> submodule (bloch_vectors) bloch_vectors_s use physics_defs, only: SCALAR, SPINOR, VECTOR, VECTORSPINOR, TENSOR use su_algebra implicit none contains <> end submodule bloch_vectors_s @ %def bloch_vectors_s @ \subsection{Preliminaries} The normalization factor $\sqrt{2N(N-1)}/N$ that enters the Bloch representation. <>= 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. <>= public :: bloch_vector_t <>= type :: bloch_vector_t private integer :: spin_type = UNKNOWN real(default), dimension(:), allocatable :: a contains <> 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. <>= procedure :: init_unpolarized => bloch_vector_init_unpolarized <>= module subroutine bloch_vector_init_unpolarized (pol, spin_type) class(bloch_vector_t), intent(out) :: pol integer, intent(in) :: spin_type end subroutine bloch_vector_init_unpolarized <>= module 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. <>= generic :: init => bloch_vector_init procedure, private :: bloch_vector_init <>= module subroutine bloch_vector_init (pol, spin_type) class(bloch_vector_t), intent(out) :: pol integer, intent(in) :: spin_type end subroutine bloch_vector_init <>= module 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. <>= procedure :: from_array => bloch_vector_from_array <>= module subroutine bloch_vector_from_array (pol, a) class(bloch_vector_t), intent(inout) :: pol real(default), dimension(:), allocatable, intent(in) :: a end subroutine bloch_vector_from_array <>= module 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. <>= procedure :: to_array => bloch_vector_to_array <>= module subroutine bloch_vector_to_array (pol, a) class(bloch_vector_t), intent(in) :: pol real(default), dimension(:), allocatable, intent(out) :: a end subroutine bloch_vector_to_array <>= module 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} <>= procedure :: write_raw => bloch_vector_write_raw procedure :: read_raw => bloch_vector_read_raw <>= module subroutine bloch_vector_write_raw (pol, u) class(bloch_vector_t), intent(in) :: pol integer, intent(in) :: u end subroutine bloch_vector_write_raw module subroutine bloch_vector_read_raw (pol, u, iostat) class(bloch_vector_t), intent(out) :: pol integer, intent(in) :: u integer, intent(out) :: iostat end subroutine bloch_vector_read_raw <>= module 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 module 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. <>= procedure :: get_n_states procedure :: get_length procedure :: hel_index => bv_helicity_index procedure :: hel_value => bv_helicity_value procedure :: bloch_factor => bv_factor <>= module function get_n_states (pol) result (n) class(bloch_vector_t), intent(in) :: pol integer :: n end function get_n_states module function get_length (pol) result (n) class(bloch_vector_t), intent(in) :: pol integer :: n end function get_length module function bv_helicity_index (pol, h) result (i) class(bloch_vector_t), intent(in) :: pol integer, intent(in) :: h integer :: i end function bv_helicity_index module function bv_helicity_value (pol, i) result (h) class(bloch_vector_t), intent(in) :: pol integer, intent(in) :: i integer :: h end function bv_helicity_value module function bv_factor (pol) result (f) class(bloch_vector_t), intent(in) :: pol real(default) :: f end function bv_factor <>= module 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 module 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 module 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 module 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 module 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. <>= procedure :: is_defined => bloch_vector_is_defined <>= module function bloch_vector_is_defined (pol) result (flag) class(bloch_vector_t), intent(in) :: pol logical :: flag end function bloch_vector_is_defined <>= module 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. <>= procedure :: is_polarized => bloch_vector_is_polarized <>= module function bloch_vector_is_polarized (pol) result (flag) class(bloch_vector_t), intent(in) :: pol logical :: flag end function bloch_vector_is_polarized <>= module 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. <>= procedure :: is_diagonal => bloch_vector_is_diagonal <>= module function bloch_vector_is_diagonal (pol) result (diagonal) class(bloch_vector_t), intent(in) :: pol logical :: diagonal end function bloch_vector_is_diagonal <>= module 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.) <>= procedure :: get_norm => bloch_vector_get_norm <>= module function bloch_vector_get_norm (pol) result (norm) class(bloch_vector_t), intent(in) :: pol real(default) :: norm end function bloch_vector_get_norm <>= module 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. <>= generic :: init => bloch_vector_init_diagonal procedure, private :: bloch_vector_init_diagonal <>= module 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 end subroutine bloch_vector_init_diagonal <>= module 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. <>= generic :: set => bloch_vector_set_diagonal procedure, private :: bloch_vector_set_diagonal <>= module subroutine bloch_vector_set_diagonal (pol, rd) class(bloch_vector_t), intent(inout) :: pol real(default), dimension(:), intent(in) :: rd end subroutine bloch_vector_set_diagonal <>= module 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. <>= procedure :: init_max_weight => bloch_vector_init_max_weight <>= module subroutine bloch_vector_init_max_weight (pol, spin_type) class(bloch_vector_t), intent(out) :: pol integer, intent(in) :: spin_type end subroutine bloch_vector_init_max_weight <>= module 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. <>= procedure :: init_vector => bloch_vector_init_vector procedure :: to_vector => bloch_vector_to_vector <>= module 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 end subroutine bloch_vector_init_vector module subroutine bloch_vector_to_vector (pol, a) class(bloch_vector_t), intent(in) :: pol real(default), dimension(3), intent(out) :: a end subroutine bloch_vector_to_vector <>= module 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 module 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. <>= generic :: init => bloch_vector_init_matrix procedure, private :: bloch_vector_init_matrix <>= module 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 end subroutine bloch_vector_init_matrix <>= module 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. <>= generic :: set => bloch_vector_set_matrix procedure, private :: bloch_vector_set_matrix <>= module subroutine bloch_vector_set_matrix (pol, r) class(bloch_vector_t), intent(inout) :: pol complex(default), dimension(:,:), intent(in) :: r end subroutine bloch_vector_set_matrix <>= module 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. <>= procedure :: to_matrix => bloch_vector_to_matrix <>= module 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 end subroutine bloch_vector_to_matrix <>= module 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]]>>= <> module bloch_vectors_ut use unit_tests use bloch_vectors_uti <> <> contains <> end module bloch_vectors_ut @ %def bloch_vectors_ut @ <<[[bloch_vectors_uti.f90]]>>= <> module bloch_vectors_uti <> use physics_defs, only: UNKNOWN, SCALAR, SPINOR, VECTOR, VECTORSPINOR, TENSOR use su_algebra, only: algebra_dimension, fundamental_dimension, helicity_value use bloch_vectors <> <> contains <> end module bloch_vectors_uti @ %def bloch_vectors_ut @ API: driver for the unit tests below. <>= public :: bloch_vectors_test <>= subroutine bloch_vectors_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> 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. <>= call test (bloch_vectors_1, "bloch_vectors_1", & "initialization", & u, results) <>= public :: bloch_vectors_1 <>= 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. <>= call test (bloch_vectors_2, "bloch_vectors_2", & "pure state (diagonal)", & u, results) <>= public :: bloch_vectors_2 <>= 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. <>= call test (bloch_vectors_3, "bloch_vectors_3", & "pure state (arbitrary)", & u, results) <>= public :: bloch_vectors_3 <>= 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) + where (abs (aimag (r)) < 1.e-14_default) & + r = cmplx (real(r, kind=default), 0._default, kind=default) 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. <>= call test (bloch_vectors_4, "bloch_vectors_4", & "raw I/O", & u, results) <>= public :: bloch_vectors_4 <>= 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. <>= call test (bloch_vectors_5, "bloch_vectors_5", & "massless state (unpolarized)", & u, results) <>= public :: bloch_vectors_5 <>= 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. <>= call test (bloch_vectors_6, "bloch_vectors_6", & "massless state (arbitrary)", & u, results) <>= public :: bloch_vectors_6 <>= 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) + where (abs (aimag (r)) < 1.e-14_default) & + r = cmplx (real(r, kind=default), 0._default, kind=default) 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. <>= call test (bloch_vectors_7, "bloch_vectors_7", & "massless state (vector)", & u, results) <>= public :: bloch_vectors_7 <>= 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]]>>= <> module polarizations <> use physics_defs, only: SCALAR, SPINOR, VECTOR, VECTORSPINOR, TENSOR use flavors use quantum_numbers use state_matrices use bloch_vectors <> <> <> <> interface <> end interface end module polarizations @ %def polarizations @ <<[[polarizations_sub.f90]]>>= <> submodule (polarizations) polarizations_s use io_units use format_defs, only: FMT_19 use diagnostics use helicities implicit none contains <> end submodule polarizations_s @ %def polarizations_s @ \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. <>= public :: polarization_t <>= type :: polarization_t private integer :: spin_type = SCALAR integer :: multiplicity = 1 integer :: chirality = 0 logical :: anti = .false. type(bloch_vector_t) :: bv contains <> 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. <>= generic, private :: init => polarization_init, polarization_init_flv procedure, private :: polarization_init procedure, private :: polarization_init_flv <>= module 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 end subroutine polarization_init module subroutine polarization_init_flv (pol, flv) class(polarization_t), intent(out) :: pol type(flavor_t), intent(in) :: flv end subroutine polarization_init_flv <>= module 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 module 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. <>= generic :: init_generic => & polarization_init_generic, & polarization_init_generic_flv procedure, private :: polarization_init_generic procedure, private :: polarization_init_generic_flv <>= module 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 end subroutine polarization_init_generic module subroutine polarization_init_generic_flv (pol, flv) class(polarization_t), intent(out) :: pol type(flavor_t), intent(in) :: flv end subroutine polarization_init_generic_flv <>= module 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 module 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. <>= procedure :: write => polarization_write <>= module 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 end subroutine polarization_write <>= module 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. <>= procedure :: write_raw => polarization_write_raw procedure :: read_raw => polarization_read_raw <>= module subroutine polarization_write_raw (pol, u) class(polarization_t), intent(in) :: pol integer, intent(in) :: u end subroutine polarization_write_raw module subroutine polarization_read_raw (pol, u, iostat) class(polarization_t), intent(out) :: pol integer, intent(in) :: u integer, intent(out), optional :: iostat end subroutine polarization_read_raw <>= module 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 module 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. <>= procedure :: is_polarized => polarization_is_polarized <>= module function polarization_is_polarized (pol) result (polarized) class(polarization_t), intent(in) :: pol logical :: polarized end function polarization_is_polarized <>= module 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. <>= procedure :: is_diagonal => polarization_is_diagonal <>= module function polarization_is_diagonal (pol) result (diagonal) class(polarization_t), intent(in) :: pol logical :: diagonal end function polarization_is_diagonal <>= module 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. Therefore, we cannot account for any sign flip and transform as-is. <>= procedure :: init_state_matrix => polarization_init_state_matrix <>= module subroutine polarization_init_state_matrix (pol, state) class(polarization_t), intent(out) :: pol type(state_matrix_t), intent(in), target :: state end subroutine polarization_init_state_matrix <>= module 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. <>= procedure :: to_state => polarization_to_state_matrix <>= module 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 end subroutine polarization_to_state_matrix <>= module 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. <>= procedure :: init_unpolarized => polarization_init_unpolarized <>= module subroutine polarization_init_unpolarized (pol, flv) class(polarization_t), intent(out) :: pol type(flavor_t), intent(in) :: flv end subroutine polarization_init_unpolarized <>= module 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. <>= procedure :: init_circular => polarization_init_circular <>= module subroutine polarization_init_circular (pol, flv, f) class(polarization_t), intent(out) :: pol type(flavor_t), intent(in) :: flv real(default), intent(in) :: f end subroutine polarization_init_circular <>= module 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. <>= procedure :: init_transversal => polarization_init_transversal <>= module 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 end subroutine polarization_init_transversal <>= module 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. <>= procedure :: init_axis => polarization_init_axis <>= module 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 end subroutine polarization_init_axis <>= module 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. <>= procedure :: init_angles => polarization_init_angles <>= module 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 end subroutine polarization_init_angles <>= module 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. <>= procedure :: init_longitudinal => polarization_init_longitudinal <>= module subroutine polarization_init_longitudinal (pol, flv, f) class(polarization_t), intent(out) :: pol type(flavor_t), intent(in) :: flv real(default), intent(in) :: f end subroutine polarization_init_longitudinal <>= module 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. <>= procedure :: init_diagonal => polarization_init_diagonal <>= module 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 end subroutine polarization_init_diagonal <>= module 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. <>= public :: combine_polarization_states <>= module subroutine combine_polarization_states (pol, state) type(polarization_t), dimension(:), intent(in), target :: pol type(state_matrix_t), intent(out) :: state end subroutine combine_polarization_states <>= module 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. <>= procedure :: get_axis => polarization_get_axis <>= module function polarization_get_axis (pol) result (alpha) class(polarization_t), intent(in), target :: pol real(default), dimension(3) :: alpha end function polarization_get_axis <>= module 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. <>= procedure :: to_angles => polarization_to_angles <>= module subroutine polarization_to_angles (pol, r, theta, phi) class(polarization_t), intent(in) :: pol real(default), intent(out) :: r, theta, phi end subroutine polarization_to_angles <>= module 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. <>= public :: polarization_iterator_t <>= 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 <> end type polarization_iterator_t @ %def polarization_iterator_t @ Output for debugging purposes only, therefore no format for real/complex. <>= procedure :: write => polarization_iterator_write <>= module subroutine polarization_iterator_write (it, unit) class(polarization_iterator_t), intent(in) :: it integer, intent(in), optional :: unit end subroutine polarization_iterator_write <>= module 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. <>= procedure :: init => polarization_iterator_init <>= module 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 end subroutine polarization_iterator_init <>= module 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. <>= procedure :: advance => polarization_iterator_advance <>= recursive module subroutine polarization_iterator_advance (it) class(polarization_iterator_t), intent(inout) :: it end subroutine polarization_iterator_advance <>= recursive module 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. <>= procedure :: is_valid => polarization_iterator_is_valid <>= module function polarization_iterator_is_valid (it) result (is_valid) logical :: is_valid class(polarization_iterator_t), intent(in) :: it end function polarization_iterator_is_valid <>= module 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. <>= procedure :: get_value => polarization_iterator_get_value <>= module function polarization_iterator_get_value (it) result (value) complex(default) :: value class(polarization_iterator_t), intent(in) :: it end function polarization_iterator_get_value <>= module 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. <>= procedure :: get_quantum_numbers => polarization_iterator_get_quantum_numbers <>= module function polarization_iterator_get_quantum_numbers (it) result (qn) class(polarization_iterator_t), intent(in) :: it type(quantum_numbers_t) :: qn end function polarization_iterator_get_quantum_numbers <>= module 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. <>= public :: smatrix_t <>= type :: smatrix_t private integer :: dim = 0 integer :: n_entry = 0 integer, dimension(:,:), allocatable :: index complex(default), dimension(:), allocatable :: value contains <> end type smatrix_t @ %def smatrix_t @ Output. <>= procedure :: write => smatrix_write <>= module subroutine smatrix_write (object, unit, indent) class(smatrix_t), intent(in) :: object integer, intent(in), optional :: unit, indent end subroutine smatrix_write <>= module 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. <>= procedure :: init => smatrix_init <>= module subroutine smatrix_init (smatrix, dim, n_entry) class(smatrix_t), intent(out) :: smatrix integer, intent(in) :: dim integer, intent(in) :: n_entry end subroutine smatrix_init <>= module 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. <>= procedure :: set_entry => smatrix_set_entry <>= module 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 end subroutine smatrix_set_entry <>= module 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 @ <>= procedure :: exists => smatrix_exists <>= elemental module function smatrix_exists (smatrix) result (exist) logical :: exist class(smatrix_t), intent(in) :: smatrix end function smatrix_exists <>= elemental module 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. 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. <>= public :: pmatrix_t <>= 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 <> end type pmatrix_t @ %def pmatrix_t @ Output, including extra data. (The [[indent]] argument is ignored.) <>= procedure :: write => pmatrix_write <>= module subroutine pmatrix_write (object, unit, indent) class(pmatrix_t), intent(in) :: object integer, intent(in), optional :: unit, indent end subroutine pmatrix_write <>= module 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. <>= generic :: assignment(=) => pmatrix_assign_from_smatrix procedure, private :: pmatrix_assign_from_smatrix <>= module subroutine pmatrix_assign_from_smatrix (pmatrix, smatrix) class(pmatrix_t), intent(out) :: pmatrix type(smatrix_t), intent(in) :: smatrix end subroutine pmatrix_assign_from_smatrix <>= module 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} <>= procedure :: normalize => pmatrix_normalize <>= module 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 end subroutine pmatrix_normalize <>= module 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. <>= procedure :: is_polarized => pmatrix_is_polarized <>= elemental module function pmatrix_is_polarized (pmatrix) result (flag) class(pmatrix_t), intent(in) :: pmatrix logical :: flag end function pmatrix_is_polarized <>= elemental module 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. <>= procedure :: is_diagonal => pmatrix_is_diagonal <>= elemental module function pmatrix_is_diagonal (pmatrix) result (flag) class(pmatrix_t), intent(in) :: pmatrix logical :: flag end function pmatrix_is_diagonal <>= elemental module 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. <>= procedure :: get_simple_pol => pmatrix_get_simple_pol <>= elemental module function pmatrix_get_simple_pol (pmatrix) result (pol) class(pmatrix_t), intent(in) :: pmatrix real(default) :: pol end function pmatrix_get_simple_pol <>= elemental module 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. As mentioned above, [[pmatrix_t]] does not support an antiparticle flag. <>= procedure :: init_pmatrix => polarization_init_pmatrix <>= module subroutine polarization_init_pmatrix (pol, pmatrix) class(polarization_t), intent(out) :: pol type(pmatrix_t), intent(in) :: pmatrix end subroutine polarization_init_pmatrix <>= module 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]]>>= <> module polarizations_ut use unit_tests use polarizations_uti <> <> contains <> end module polarizations_ut @ %def polarizations_ut @ <<[[polarizations_uti.f90]]>>= <> module polarizations_uti <> use flavors use model_data use polarizations <> <> contains <> end module polarizations_uti @ %def polarizations_ut @ API: driver for the unit tests below. <>= public :: polarizations_test <>= subroutine polarizations_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> end subroutine polarizations_test @ %def polarizations_test @ \subsubsection{Polarization type} Checking the setup for polarization. <>= call test (polarization_1, "polarization_1", & "check polarization setup", & u, results) <>= public :: polarization_1 <>= 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. <>= call test (polarization_2, "polarization_2", & "matrix polarization setup", & u, results) <>= public :: polarization_2 <>= 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]]>>= <> module particles <> <> <> use lorentz use phs_points, only: phs_point_t, assignment(=) use model_data use flavors use colors use helicities use quantum_numbers use state_matrices use interactions use subevents use polarizations <> <> <> <> <> interface <> end interface end module particles @ %def particles @ <<[[particles_sub.f90]]>>= <> submodule (particles) particles_s 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 pdg_arrays, only: is_quark, is_gluon implicit none contains <> end submodule particles_s @ %def particles_s @ \subsection{The particle type} \subsubsection{Particle status codes} The overall status codes (incoming/outgoing etc.) are inherited from the module [[subevents]]. Polarization status: <>= 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. <>= public :: particle_t <>= 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 <> end type particle_t @ %def particle_t @ Copy a particle. (Deep copy) This excludes the parent-child relations. <>= generic :: init => init_particle procedure :: init_particle => particle_init_particle <>= module subroutine particle_init_particle (prt_out, prt_in) class(particle_t), intent(out) :: prt_out type(particle_t), intent(in) :: prt_in end subroutine particle_init_particle <>= module 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. <>= generic :: init => init_external procedure :: init_external => particle_init_external <>= module 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 end subroutine particle_init_external <>= module 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. <>= generic :: init => init_state procedure :: init_state => particle_init_state <>= module 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 end subroutine particle_init_state <>= module 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. <>= procedure :: final => particle_final <>= module subroutine particle_final (prt) class(particle_t), intent(inout) :: prt end subroutine particle_final <>= module 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} <>= procedure :: write => particle_write <>= module 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 end subroutine particle_write <>= module 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: <>= procedure :: write_raw => particle_write_raw procedure :: read_raw => particle_read_raw <>= module subroutine particle_write_raw (prt, u) class(particle_t), intent(in) :: prt integer, intent(in) :: u end subroutine particle_write_raw module subroutine particle_read_raw (prt, u, iostat) class(particle_t), intent(out) :: prt integer, intent(in) :: u integer, intent(out) :: iostat end subroutine particle_read_raw <>= module 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 module 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. <>= procedure :: reset_status => particle_reset_status <>= elemental module subroutine particle_reset_status (prt, status) class(particle_t), intent(inout) :: prt integer, intent(in) :: status end subroutine particle_reset_status <>= elemental module 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. <>= procedure :: set_color => particle_set_color <>= elemental module subroutine particle_set_color (prt, col) class(particle_t), intent(inout) :: prt type(color_t), intent(in) :: col end subroutine particle_set_color <>= elemental module 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. <>= procedure :: set_flavor => particle_set_flavor <>= module subroutine particle_set_flavor (prt, flv) class(particle_t), intent(inout) :: prt type(flavor_t), intent(in) :: flv end subroutine particle_set_flavor <>= module 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. <>= procedure :: set_helicity => particle_set_helicity <>= module subroutine particle_set_helicity (prt, hel) class(particle_t), intent(inout) :: prt type(helicity_t), intent(in) :: hel end subroutine particle_set_helicity <>= module 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. <>= procedure :: set_pol => particle_set_pol <>= module subroutine particle_set_pol (prt, pol) class(particle_t), intent(inout) :: prt type(polarization_t), intent(in) :: pol end subroutine particle_set_pol <>= module 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. <>= procedure :: set_model => particle_set_model <>= module subroutine particle_set_model (prt, model) class(particle_t), intent(inout) :: prt class(model_data_t), intent(in), target :: model end subroutine particle_set_model <>= module 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. <>= procedure :: set_momentum => particle_set_momentum <>= elemental module 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 end subroutine particle_set_momentum <>= elemental module 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. <>= procedure :: set_resonance_flag => particle_set_resonance_flag <>= 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. <>= procedure :: set_children => particle_set_children procedure :: set_parents => particle_set_parents <>= module subroutine particle_set_children (prt, idx) class(particle_t), intent(inout) :: prt integer, dimension(:), intent(in) :: idx end subroutine particle_set_children module subroutine particle_set_parents (prt, idx) class(particle_t), intent(inout) :: prt integer, dimension(:), intent(in) :: idx end subroutine particle_set_parents <>= module 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 module 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 @ <>= procedure :: add_child => particle_add_child <>= module subroutine particle_add_child (prt, new_child) class(particle_t), intent(inout) :: prt integer, intent(in) :: new_child end subroutine particle_add_child <>= module 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 @ <>= procedure :: add_children => particle_add_children <>= module subroutine particle_add_children (prt, new_child) class(particle_t), intent(inout) :: prt integer, dimension(:), intent(in) :: new_child end subroutine particle_add_children <>= module 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 @ <>= procedure :: set_status => particle_set_status <>= elemental module subroutine particle_set_status (prt, status) class(particle_t), intent(inout) :: prt integer, intent(in) :: status end subroutine particle_set_status <>= elemental module 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 @ <>= procedure :: set_polarization => particle_set_polarization <>= module subroutine particle_set_polarization (prt, polarization) class(particle_t), intent(inout) :: prt integer, intent(in) :: polarization end subroutine particle_set_polarization <>= module 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 @ <>= 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 <>= module subroutine particle_set_vertex_from_vector4 (prt, vertex) class(particle_t), intent(inout) :: prt type(vector4_t), intent(in) :: vertex end subroutine particle_set_vertex_from_vector4 module subroutine particle_set_vertex_from_vector3 (prt, vertex) class(particle_t), intent(inout) :: prt type(vector3_t), intent(in) :: vertex end subroutine particle_set_vertex_from_vector3 module 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 end subroutine particle_set_vertex_from_xyzt module subroutine particle_set_vertex_from_xyz (prt, vx, vy, vz) class(particle_t), intent(inout) :: prt real(default), intent(in) :: vx, vy, vz end subroutine particle_set_vertex_from_xyz <>= module 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 module 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 module 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 module 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. <>= procedure :: set_lifetime => particle_set_lifetime <>= elemental module subroutine particle_set_lifetime (prt, lifetime) class(particle_t), intent(inout) :: prt real(default), intent(in) :: lifetime end subroutine particle_set_lifetime <>= elemental module 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. <>= procedure :: get_status => particle_get_status <>= elemental module function particle_get_status (prt) result (status) integer :: status class(particle_t), intent(in) :: prt end function particle_get_status <>= elemental module 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. <>= procedure :: is_real => particle_is_real <>= elemental module function particle_is_real (prt, keep_beams) result (flag) logical :: flag, kb class(particle_t), intent(in) :: prt logical, intent(in), optional :: keep_beams end function particle_is_real <>= elemental module 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 @ <>= procedure :: is_colored => particle_is_colored <>= elemental module function particle_is_colored (particle) result (flag) logical :: flag class(particle_t), intent(in) :: particle end function particle_is_colored <>= elemental module 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. <>= procedure :: is_hadronic_beam_remnant => particle_is_hadronic_beam_remnant <>= elemental module function particle_is_hadronic_beam_remnant (particle) result (flag) class(particle_t), intent(in) :: particle logical :: flag end function particle_is_hadronic_beam_remnant <>= elemental module 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 @ <>= procedure :: is_beam_remnant => particle_is_beam_remnant <>= elemental module function particle_is_beam_remnant (particle) result (flag) class(particle_t), intent(in) :: particle logical :: flag end function particle_is_beam_remnant <>= elemental module 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. <>= procedure :: get_polarization_status => particle_get_polarization_status <>= elemental module function particle_get_polarization_status (prt) result (status) integer :: status class(particle_t), intent(in) :: prt end function particle_get_polarization_status <>= elemental module 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. <>= procedure :: get_pdg => particle_get_pdg <>= elemental module function particle_get_pdg (prt) result (pdg) integer :: pdg class(particle_t), intent(in) :: prt end function particle_get_pdg <>= elemental module 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. <>= procedure :: get_color => particle_get_color <>= pure module function particle_get_color (prt) result (col) integer, dimension(2) :: col class(particle_t), intent(in) :: prt end function particle_get_color <>= pure module 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. <>= procedure :: get_polarization => particle_get_polarization <>= module function particle_get_polarization (prt) result (pol) class(particle_t), intent(in) :: prt type(polarization_t) :: pol end function particle_get_polarization <>= module 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. <>= procedure :: get_flv => particle_get_flv procedure :: get_col => particle_get_col procedure :: get_hel => particle_get_hel <>= module function particle_get_flv (prt) result (flv) class(particle_t), intent(in) :: prt type(flavor_t) :: flv end function particle_get_flv module function particle_get_col (prt) result (col) class(particle_t), intent(in) :: prt type(color_t) :: col end function particle_get_col module function particle_get_hel (prt) result (hel) class(particle_t), intent(in) :: prt type(helicity_t) :: hel end function particle_get_hel <>= module 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 module 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 module 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). <>= procedure :: get_helicity => particle_get_helicity <>= elemental module function particle_get_helicity (prt) result (hel) integer :: hel class(particle_t), intent(in) :: prt end function particle_get_helicity <>= elemental module 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 <>= procedure :: get_n_parents => particle_get_n_parents procedure :: get_n_children => particle_get_n_children <>= elemental module function particle_get_n_parents (prt) result (n) integer :: n class(particle_t), intent(in) :: prt end function particle_get_n_parents elemental module function particle_get_n_children (prt) result (n) integer :: n class(particle_t), intent(in) :: prt end function particle_get_n_children <>= elemental module 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 module 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. <>= procedure :: get_parents => particle_get_parents procedure :: get_children => particle_get_children <>= module function particle_get_parents (prt) result (parent) class(particle_t), intent(in) :: prt integer, dimension(:), allocatable :: parent end function particle_get_parents module function particle_get_children (prt) result (child) class(particle_t), intent(in) :: prt integer, dimension(:), allocatable :: child end function particle_get_children <>= module 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 module 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 @ <>= procedure :: has_children => particle_has_children <>= elemental module function particle_has_children (prt) result (has_children) logical :: has_children class(particle_t), intent(in) :: prt end function particle_has_children <>= elemental module 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 @ <>= procedure :: has_parents => particle_has_parents <>= elemental module function particle_has_parents (prt) result (has_parents) logical :: has_parents class(particle_t), intent(in) :: prt end function particle_has_parents <>= elemental module 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. <>= procedure :: get_momentum => particle_get_momentum procedure :: get_p2 => particle_get_p2 <>= elemental module function particle_get_momentum (prt) result (p) type(vector4_t) :: p class(particle_t), intent(in) :: prt end function particle_get_momentum elemental module function particle_get_p2 (prt) result (p2) real(default) :: p2 class(particle_t), intent(in) :: prt end function particle_get_p2 <>= elemental module 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 module 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. <>= procedure :: get_vertex => particle_get_vertex <>= elemental module function particle_get_vertex (prt) result (vtx) type(vector4_t) :: vtx class(particle_t), intent(in) :: prt end function particle_get_vertex <>= elemental module 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. <>= procedure :: get_lifetime => particle_get_lifetime <>= elemental module function particle_get_lifetime (prt) result (lifetime) real(default) :: lifetime class(particle_t), intent(in) :: prt end function particle_get_lifetime <>= elemental module 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 @ <>= procedure :: momentum_to_pythia6 => particle_momentum_to_pythia6 <>= pure module function particle_momentum_to_pythia6 (prt) result (p) real(double), dimension(1:5) :: p class(particle_t), intent(in) :: prt end function particle_momentum_to_pythia6 <>= pure module 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. <>= public :: particle_set_t <>= 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 <> end type particle_set_t @ %def particle_set_t @ A particle set can be initialized from an interaction or from a HepMC event record. <>= 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. <>= module 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 end subroutine particle_set_init_interaction <>= module 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 is_valid = .true. 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 (int%get_children (i)) call particle_set%prt(j)%set_parents (int%get_parents (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. <>= generic :: assignment(=) => init_particle_set generic :: init => init_particle_set procedure :: init_particle_set => particle_set_init_particle_set <>= module 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 end subroutine particle_set_init_particle_set <>= module 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. <>= procedure :: set_model => particle_set_set_model <>= module subroutine particle_set_set_model (particle_set, model) class(particle_set_t), intent(inout) :: particle_set class(model_data_t), intent(in), target :: model end subroutine particle_set_set_model <>= module 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. <>= procedure :: final => particle_set_final <>= module subroutine particle_set_final (particle_set) class(particle_set_t), intent(inout) :: particle_set end subroutine particle_set_final <>= module 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. <>= procedure :: basic_init => particle_set_basic_init <>= module 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 end subroutine particle_set_basic_init <>= module 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. <>= procedure :: init_direct => particle_set_init_direct <>= module 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 end subroutine particle_set_init_direct <>= module 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. <>= procedure :: transfer => particle_set_transfer <>= module 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 end subroutine particle_set_transfer <>= module 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) pset%factorization_mode = source%factorization_mode 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 ())) call pset%prt(map(i))%set_polarization & (source%prt(i)%get_polarization_status ()) select case (source%prt(i)%get_polarization_status ()) case (PRT_DEFINITE_HELICITY) call pset%prt(map(i))%set_helicity (source%prt(i)%get_hel ()) case (PRT_GENERIC_POLARIZATION) call pset%prt(map(i))%set_pol (source%prt(i)%get_polarization ()) end select 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. <>= procedure :: insert => particle_set_insert <>= module 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 end subroutine particle_set_insert <>= module 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. <>= procedure :: recover_color => particle_set_recover_color <>= module subroutine particle_set_recover_color (pset, i) class(particle_set_t), intent(inout) :: pset integer, intent(in) :: i end subroutine particle_set_recover_color <>= module 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} <>= 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 <>= module function particle_set_get_color_all (particle_set) result (col) class(particle_set_t), intent(in) :: particle_set type(color_t), dimension(:), allocatable :: col end function particle_set_get_color_all <>= module 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 @ <>= module 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 end function particle_set_get_color_indices <>= module 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. <>= 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 <>= module 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 end subroutine particle_set_set_color_single module 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 end subroutine particle_set_set_color_indices module subroutine particle_set_set_color_all (particle_set, col) class(particle_set_t), intent(inout) :: particle_set type(color_t), dimension(:), intent(in) :: col end subroutine particle_set_set_color_all <>= module 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 module 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 module 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. <>= procedure :: find_prt_invalid_color => particle_set_find_prt_invalid_color <>= module 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 end subroutine particle_set_find_prt_invalid_color <>= module 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 @ <>= 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 <>= module function particle_set_get_momenta_all (particle_set) result (p) class(particle_set_t), intent(in) :: particle_set type(vector4_t), dimension(:), allocatable :: p end function particle_set_get_momenta_all <>= module 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 @ <>= module 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 end function particle_set_get_momenta_indices <>= module 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. <>= 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 <>= module 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 end subroutine particle_set_set_momentum_single module 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 end subroutine particle_set_set_momentum_indices module 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 end subroutine particle_set_set_momentum_all <>= module 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 module 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 module 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. <>= procedure :: recover_momentum => particle_set_recover_momentum <>= module subroutine particle_set_recover_momentum (particle_set, i) class(particle_set_t), intent(inout) :: particle_set integer, intent(in) :: i end subroutine particle_set_recover_momentum <>= module 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 @ <>= procedure :: replace_incoming_momenta => particle_set_replace_incoming_momenta <>= module subroutine particle_set_replace_incoming_momenta (particle_set, p) class(particle_set_t), intent(inout) :: particle_set type(vector4_t), intent(in), dimension(:) :: p end subroutine particle_set_replace_incoming_momenta <>= module 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 @ <>= procedure :: replace_outgoing_momenta => particle_set_replace_outgoing_momenta <>= module subroutine particle_set_replace_outgoing_momenta (particle_set, p) class(particle_set_t), intent(inout) :: particle_set type(vector4_t), intent(in), dimension(:) :: p end subroutine particle_set_replace_outgoing_momenta <>= module 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 @ <>= procedure :: get_outgoing_momenta => particle_set_get_outgoing_momenta <>= module function particle_set_get_outgoing_momenta (particle_set) result (p) class(particle_set_t), intent(in) :: particle_set type(vector4_t), dimension(:), allocatable :: p end function particle_set_get_outgoing_momenta <>= module 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 @ <>= procedure :: parent_add_child => particle_set_parent_add_child <>= module subroutine particle_set_parent_add_child (particle_set, parent, child) class(particle_set_t), intent(inout) :: particle_set integer, intent(in) :: parent, child end subroutine particle_set_parent_add_child <>= module 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 in ambiguous cases, we update the [[particle_set]]. The reference for this procedure is [0709.2092], Sec. 4.5.1. We do not (yet) account for helicities and polarisations here nor do we update the beam remnant color and momenta. <>= procedure :: build_radiation => particle_set_build_radiation <>= module 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 end subroutine particle_set_build_radiation <>= module 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, j, pdg_index_emitter, pdg_index_radiation, new_color_index integer, dimension(:), allocatable :: parents, children type(vector4_t) :: mom_sum_children type(flavor_t) :: new_flv, real_emitter_flavor logical, dimension(:), allocatable :: status_mask integer, dimension(:), allocatable :: & i_in1, i_beam1, i_remnant1, i_virt1, i_res1, i_out1 integer, dimension(:), allocatable :: & i_in2, i_beam2, i_remnant2, i_virt2, i_res2, i_out2 integer :: n_in1, n_beam1, n_remnant1, n_virt1, n_res1, n_out1 integer :: n_in2, n_beam2, n_remnant2, n_virt2, n_res2, n_out2 integer :: n, n_tot, i_emitter logical :: is_fsr 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_RESONANT end do n_res1 = count (status_mask) allocate (i_res1 (n_res1)) i_res1 = 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_res2 = n_res1 n_virt2 = n_virt1 n_out2 = n_out1 + 1 n_tot = n_in2 + n_beam2 + n_remnant2 + n_virt2 + n_res2 + n_out2 allocate (i_in2 (n_in2), i_beam2 (n_beam2), i_remnant2 (n_remnant2), i_res2 (n_res2)) i_in2 = i_in1; i_beam2 = i_beam1; i_remnant2 = i_remnant1; i_res2 = i_res1 allocate (i_virt2 (n_virt2)) i_virt2(1 : n_virt1) = i_virt1 allocate (i_out2 (n_out2)) i_out2(1 : n_out1) = i_out1(1 : 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 + n_res2 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) if (size (i_res1) > 0) new_particle_set%prt(i_res2) = particle_set%prt(i_res1) do i = 1, n_virt1 new_particle_set%prt(i_virt2(i)) = particle_set%prt(i_virt1(i)) 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) is_fsr = emitter > n_in1 if (is_fsr) then i_emitter = emitter + n_virt2 + n_res2 + n_remnant2 + n_beam2 else i_emitter = emitter + n_beam2 end if call real_emitter_flavor%init (pdg_index_emitter, model) call new_particle_set%prt(i_emitter)%set_flavor(real_emitter_flavor) new_color_index = 0 do i = 1, n_tot - 1 new_color_index = max(maxval(abs(particle_set%prt(i)%get_color())), new_color_index) end do new_color_index = new_color_index + 1 call reassign_colors (new_particle, new_particle_set%prt(i_emitter), & pdg_index_radiation, pdg_index_emitter, new_color_index, is_fsr, r_color) call new_particle%set_flavor (new_flv) new_particle_set%prt(n_tot) = new_particle !!! Set proper parents for outgoing particles if (is_fsr) then call new_particle_set%prt(n_tot)%set_parents ( & new_particle_set%prt(i_emitter)%get_parents ()) else call new_particle_set%prt(n_tot)%set_parents (i_in2) end if do i = n_in2 + n_beam2 + n_remnant2 + n_virt1 + 1, & n_in2 + n_beam2 + n_remnant2 + n_virt2 + n_res2 allocate(children(0)) mom_sum_children = vector4_null do j = n_in2 + n_beam2 + n_remnant2, n_tot if (any(new_particle_set%prt(j)%get_parents() == i)) then children = [children, j] if (new_particle_set%prt(j)%get_status () == PRT_OUTGOING) then mom_sum_children = mom_sum_children & + new_particle_set%prt(j)%get_momentum () end if end if end do call new_particle_set%prt(i)%set_children (children) if (mom_sum_children /= vector4_null) then call new_particle_set%set_momentum (i, mom_sum_children) end if deallocate(children) end do call particle_set%init (new_particle_set) contains <> subroutine reassign_colors (prt_radiated, prt_emitter, flv_rad, flv_em, & new_color_index, is_fsr, r_col) type(particle_t), intent(inout) :: prt_radiated, prt_emitter integer, intent(in) :: flv_rad, flv_em, new_color_index logical, intent(in) :: is_fsr real(default), intent(in) :: r_col type(color_t) :: col_rad, col_em if (is_fsr) then if (is_quark (flv_em) .and. is_gluon (flv_rad)) then call reassign_colors_q_to_qg_fsr (prt_emitter, new_color_index, col_rad, col_em) else if (is_gluon (flv_em) .and. is_gluon (flv_rad)) then call reassign_colors_g_to_gg_fsr (prt_emitter, r_col, new_color_index, col_rad, col_em) else if (is_quark (flv_em) .and. is_quark (flv_rad)) then call reassign_colors_g_to_qq_fsr (prt_emitter, flv_em, col_rad, col_em) else call msg_fatal ("reassign_colors: invalid splitting") end if else if (is_quark (flv_em) .and. is_gluon (flv_rad)) then call reassign_colors_q_to_qg_isr (prt_emitter, new_color_index, col_rad, col_em) else if (is_quark (flv_em) .and. is_quark (flv_rad)) then call reassign_colors_g_to_qq_isr (prt_emitter, flv_rad, col_rad, col_em) else if (is_gluon (flv_em) .and. is_quark (flv_rad)) then call reassign_colors_q_to_gq_isr (prt_emitter, flv_rad, new_color_index, col_rad, col_em) else if (is_gluon (flv_em) .and. is_gluon (flv_rad)) then call reassign_colors_g_to_gg_isr (prt_emitter, r_col, new_color_index, col_rad, col_em) else call msg_fatal ("reassign_colors: invalid splitting") end if end if call prt_emitter%set_color (col_em) call prt_radiated%set_color (col_rad) end subroutine reassign_colors subroutine reassign_colors_q_to_qg_fsr (prt_emitter, new_color_index, & col_rad, col_em) type(particle_t), intent(in) :: prt_emitter integer, intent(in) :: new_color_index 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 = color_em(2) /= 0 if (is_anti_quark) then i1 = 2; i2 = 1 end if 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_q_to_qg_fsr subroutine reassign_colors_g_to_gg_fsr (prt_emitter, random, new_color_index, & col_rad, col_em) type(particle_t), intent(in) :: prt_emitter real(default), intent(in) :: random integer, intent(in) :: new_color_index type(color_t), intent(out) :: col_rad, col_em integer, dimension(2) :: color_rad, color_em integer :: i1, i2 color_em = prt_emitter%get_color () 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_g_to_gg_fsr subroutine reassign_colors_g_to_qq_fsr (prt_emitter, pdg_emitter, col_rad, col_em) 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_g_to_qq_fsr subroutine reassign_colors_q_to_qg_isr (prt_emitter, new_color_index, & col_rad, col_em) type(particle_t), intent(in) :: prt_emitter integer, intent(in) :: new_color_index 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 = color_em(2) /= 0 if (is_anti_quark) then i1 = 2; i2 = 1 end if color_rad(i2) = color_em(i1) color_rad(i1) = 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_q_to_qg_isr subroutine reassign_colors_g_to_qq_isr (prt_emitter, pdg_rad, col_rad, col_em) type(particle_t), intent(in) :: prt_emitter integer, intent(in) :: pdg_rad 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_rad < 0 if (is_anti_quark) then i1 = 2; i2 = 1 end if color_rad(i1) = color_em(i2) color_rad(i2) = 0 color_em(i2) = 0 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_g_to_qq_isr subroutine reassign_colors_q_to_gq_isr (prt_emitter, pdg_rad, new_color_index, & col_rad, col_em) type(particle_t), intent(in) :: prt_emitter integer, intent(in) :: pdg_rad, new_color_index type(color_t), intent(out) :: col_rad, col_em integer, dimension(2) :: color_rad, color_em integer :: i1, i2 logical :: rad_is_quark color_em = prt_emitter%get_color () i1 = 1; i2 = 2 rad_is_quark = pdg_rad > 0 if (rad_is_quark) then i1 = 2; i2 = 1 end if color_rad(i1) = 0 color_rad(i2) = new_color_index 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_q_to_gq_isr subroutine reassign_colors_g_to_gg_isr (prt_emitter, random, new_color_index, & col_rad, col_em) type(particle_t), intent(in) :: prt_emitter real(default), intent(in) :: random integer, intent(in) :: new_color_index type(color_t), intent(out) :: col_rad, col_em integer, dimension(2) :: color_rad, color_em integer :: i1, i2 color_em = prt_emitter%get_color () i1 = 1; i2 = 2 if (random < 0.5) then i1 = 2; i2 = 1 end if color_rad(i2) = new_color_index color_rad(i1) = 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_g_to_gg_isr 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. <>= 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) <>= procedure :: write => particle_set_write <>= module 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 end subroutine particle_set_write <>= module 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. <>= procedure :: write_raw => particle_set_write_raw procedure :: read_raw => particle_set_read_raw <>= module subroutine particle_set_write_raw (particle_set, u) class(particle_set_t), intent(in) :: particle_set integer, intent(in) :: u end subroutine particle_set_write_raw module 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 end subroutine particle_set_read_raw <>= module 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 module 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]]. <>= procedure :: get_real_parents => particle_set_get_real_parents procedure :: get_real_children => particle_set_get_real_children <>= module 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 end function particle_set_get_real_parents module 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, intent(in), optional :: keep_beams end function particle_set_get_real_children <>= module 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 module 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. <>= 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 <>= module function particle_set_get_n_beam (pset) result (n_beam) class(particle_set_t), intent(in) :: pset integer :: n_beam end function particle_set_get_n_beam module function particle_set_get_n_in (pset) result (n_in) class(particle_set_t), intent(in) :: pset integer :: n_in end function particle_set_get_n_in module function particle_set_get_n_vir (pset) result (n_vir) class(particle_set_t), intent(in) :: pset integer :: n_vir end function particle_set_get_n_vir module function particle_set_get_n_out (pset) result (n_out) class(particle_set_t), intent(in) :: pset integer :: n_out end function particle_set_get_n_out module function particle_set_get_n_tot (pset) result (n_tot) class(particle_set_t), intent(in) :: pset integer :: n_tot end function particle_set_get_n_tot module function particle_set_get_n_remnants (pset) result (n_remn) class(particle_set_t), intent(in) :: pset integer :: n_remn end function particle_set_get_n_remnants <>= module 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 module 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 module 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 module 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 module 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 module 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 <>= procedure :: get_particle => particle_set_get_particle <>= module function particle_set_get_particle (pset, index) result (particle) class(particle_set_t), intent(in) :: pset integer, intent(in) :: index type(particle_t) :: particle end function particle_set_get_particle <>= module 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 @ <>= procedure :: get_indices => particle_set_get_indices <>= pure module 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 end function particle_set_get_indices <>= pure module 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 @ Copy the subset of physical momenta to a [[phs_point]] container. <>= procedure :: get_in_and_out_momenta => particle_set_get_in_and_out_momenta <>= module 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 end function particle_set_get_in_and_out_momenta <>= module 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]]. <>= procedure :: without_hadronic_remnants => & particle_set_without_hadronic_remnants <>= module 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 end subroutine particle_set_without_hadronic_remnants <>= module 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) <> 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 <>= 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]]. <>= procedure :: without_remnants => particle_set_without_remnants <>= module 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 end subroutine particle_set_without_remnants <>= module 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) <> 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 @ <>= procedure :: find_particle => particle_set_find_particle <>= pure module 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 end function particle_set_find_particle <>= pure module 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 logical, dimension(0:3) :: equals idx = 0 do i = 1, size (particle_set%prt) if (particle_set%prt(i)%flv%get_pdg () == pdg) then equals = nearly_equal (particle_set%prt(i)%p%p, momentum%p, & abs_smallness, rel_smallness) if (all (equals)) then idx = i return end if end if end do end function particle_set_find_particle @ %def particle_set_find_particle <>= procedure :: reverse_find_particle => particle_set_reverse_find_particle <>= pure module 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 end function particle_set_reverse_find_particle <>= pure module 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$. <>= procedure :: remove_duplicates => particle_set_remove_duplicates <>= module subroutine particle_set_remove_duplicates (particle_set, smallness) class(particle_set_t), intent(inout) :: particle_set real(default), intent(in) :: smallness end subroutine particle_set_remove_duplicates <>= module 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 <> end subroutine particle_set_remove_duplicates @ %def particle_set_remove_duplicates @ This does not catch all cases. Missing are splittings of the type $i \to \text{something and} j$. <>= 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 if (debug_on) call msg_debug2 (D_PARTICLES, & "Particles: Will remove duplicate of i", i) if (debug_on) 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 @ <>= 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 @ <>= 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 if (debug_on) call msg_debug (D_PARTICLES, "Particles: Removing duplicates") if (debug_on) 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. <>= procedure :: reset_status => particle_set_reset_status <>= module 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 end subroutine particle_set_reset_status <>= module 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. <>= procedure :: reduce => particle_set_reduce <>= module 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 end subroutine particle_set_reduce <>= module 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 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. <>= procedure :: filter_particles => particle_set_filter_particles <>= module 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 end subroutine particle_set_filter_particles <>= module 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 if (debug_on) 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 <> end subroutine particle_set_filter_particles @ %def particles_set_filter_particles <>= 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 <>= 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. <>= type :: particle_entry_t integer :: src = 0 integer :: status = 0 integer :: orig = 0 integer :: copy = 0 end type particle_entry_t <>= procedure :: to_hepevt_form => particle_set_to_hepevt_form <>= module 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 end subroutine particle_set_to_hepevt_form <>= module 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), 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. The main task is to find the original hard process, by following the event history. In-state: take those particles which are flagged as [[PRT_INCOMING]] Out-state: try to be smart by checking the immediate children of the incoming particles. If the [[state_flv]] table is present, check any [[PRT_RESONANT]] particles that we get this way, whether they are potential out-particles by their PDG codes. If not, replace them by their children, recursively. (Resonances may have been inserted by the corresponding event transform.) [WK 21-02-16] Revised the algorithm for the case [[recover_beams]] = false, i.e., the particle set contains beams and radiation. This does not mean that the particle set contains the complete radiation history. To make up for missing information, we follow the history in the interaction one step backwards and do a bit of guesswork to match this to the possibly incomplete history in the particle set. [The current implementation allows only for one stage of radiation; this could be improved by iterating the procedure!] [WK 21-03-21] Amended the [[find_hard_process_in_pset]] algorithm as follows: Occasionally, PYTHIA adds a stepchild to the decay of a resonance that WHIZARD has inserted, a shower object that also has other particles in the event as parents. Such objects must not enter the hard-process record. Therefore, resonance child particle objects are ignored if they have more than one parent. <>= procedure :: fill_interaction => particle_set_fill_interaction <>= module subroutine particle_set_fill_interaction & (pset, int, n_in, recover_beams, check_match, state_flv, success) 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 logical, intent(out), optional :: success end subroutine particle_set_fill_interaction <>= module subroutine particle_set_fill_interaction & (pset, int, n_in, recover_beams, check_match, state_flv, success) 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 logical, intent(out), optional :: success 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, state_flv, success) if (present (success)) then if (size (i_in) /= n_in) success = .false. if (size (p_in) /= n_in) success = .false. if (size (p_out) /= n_out) success = .false. if (.not. success) return else 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 end if call extract_hard_process_from_pset (pdg) call determine_map_for_hard_process (map, state_flv, success) if (present (success)) then if (.not. success) return end if call map_handle_duplicates (map) if (.not. r_beams) then call determine_map_for_beams (map) call map_handle_duplicates (map) call determine_map_for_radiation (map, i_in, p_in) call map_handle_duplicates (map) 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 if (.not. i_set(map(p))) then call int%set_momentum (pset%prt(p)%get_momentum (), map(p)) i_set(map(p)) = .true. end if end if end do if (r_beams) then do i = 1, n_in call reconstruct_beam_and_radiation (i, i_set) end do else do i = int%get_n_tot (), 1, -1 if (.not. i_set(i)) call reconstruct_missing (i, i_set) end do end if if (any (.not. i_set)) then if (present (success)) then success = .false. else call err_map end if end if contains 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 = int%get_n_parents (i) if (n_in_i /= n_in) call err_int_n_in allocate (i_in (n_in)) i_in = int%get_parents (i) i = i_in(1) n_out = int%get_n_children (i) allocate (i_out (n_out)) i_out = int%get_children (i) end subroutine find_hard_process_in_int subroutine find_hard_process_in_pset (p_in, p_out, state_flv, success) integer, dimension(:), allocatable, intent(out) :: p_in, p_out type(state_flv_content_t), intent(in), optional :: state_flv logical, intent(out), optional :: success integer, dimension(:), allocatable :: p_status, p_idx, p_child integer :: n_out_p, n_child, n_shift integer :: i, k, c allocate (p_status (pset%n_tot), p_idx (pset%n_tot), p_child (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) allocate (p_out (n_out)) n_out_p = pset%prt(i)%get_n_children () p_out(1:n_out_p) = particle_get_children (pset%prt(i)) do k = 1, size (p_out) i = p_out(k) if (present (state_flv)) then do while (pset%prt(i)%get_status () == PRT_RESONANT) if (state_flv%contains (pset%prt(i)%get_pdg ())) exit n_child = pset%prt(i)%get_n_children () p_child(1:n_child) = particle_get_children (pset%prt(i)) n_shift = -1 do c = 1, n_child if (pset%prt(p_child(c))%get_n_parents () == 1) then n_shift = n_shift + 1 else p_child(c) = 0 end if end do if (n_shift < 0) then if (present (success)) then success = .false. return else call err_mismatch end if end if p_out(k+1+n_shift:n_out_p+n_shift) = p_out(k+1:n_out_p) n_out_p = n_out_p + n_shift do c = 1, n_child if (p_child(c) /= 0) then p_out(k+c-1) = p_child(c) end if end do i = p_out(k) end do end if end do if (present (success)) success = .true. end subroutine find_hard_process_in_pset 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, success) integer, dimension(:), allocatable, intent(out) :: map type(state_flv_content_t), intent(in), optional :: state_flv logical, intent(out), optional :: success integer, dimension(:), allocatable :: pdg_i, map_i integer :: n_tot logical, dimension(:), allocatable :: mask_i, mask_p logical :: match 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, match, map_i) if (present (success)) then success = match end if if (.not. match) then if (present (success)) then return else call err_mismatch end if end if 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)) 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 subroutine map_handle_duplicates (map) integer, dimension(:), intent(inout) :: map integer, dimension(1) :: p_parent, p_child integer :: p do p = 1, pset%n_tot if (map(p) == 0) then if (pset%prt(p)%get_n_parents () == 1) then p_parent = pset%prt(p)%get_parents () if (map(p_parent(1)) /= 0) then if (pset%prt(p_parent(1))%get_n_children () == 1) then map(p) = map(p_parent(1)) end if end if end if end if end do do p = pset%n_tot, 1, -1 if (map(p) == 0) then if (pset%prt(p)%get_n_children () == 1) then p_child = pset%prt(p)%get_children () if (map(p_child(1)) /= 0) then if (pset%prt(p_child(1))%get_n_parents () == 1) then map(p) = map(p_child(1)) end if end if end if end if end do end subroutine map_handle_duplicates subroutine determine_map_for_beams (map) integer, dimension(:), intent(inout) :: map select case (n_in) case (1); map(1) = 1 case (2); map(1:2) = [1,2] end select end subroutine determine_map_for_beams subroutine determine_map_for_radiation (map, i_in, p_in) integer, dimension(:), intent(inout) :: map integer, dimension(:), intent(in) :: i_in integer, dimension(:), intent(in) :: p_in integer, dimension(:), allocatable :: i_cur, p_cur integer, dimension(:), allocatable :: i_par, p_par, i_rad, p_rad integer :: i, p integer :: b, r i_cur = i_in p_cur = p_in do b = 1, n_in i = i_cur(b) p = p_cur(b) i_par = int%get_parents (i) p_par = pset%prt(p)%get_parents () if (size (i_par) == 0 .or. size (p_par) == 0) cycle if (size (p_par) == 1) then if (pset%prt(p_par(1))%get_n_children () == 1) then p_par = pset%prt(p_par(1))%get_parents () ! copy of entry end if end if i_rad = int%get_children (i_par(1)) p_rad = pset%prt(p_par(1))%get_children () do r = 1, size (i_rad) if (any (map == i_rad(r))) i_rad(r) = 0 end do i_rad = pack (i_rad, i_rad /= 0) do r = 1, size (p_rad) if (map(p_rad(r)) /= 0) p_rad(r) = 0 end do p_rad = pack (p_rad, p_rad /= 0) do r = 1, min (size (i_rad), size (p_rad)) map(p_rad(r)) = i_rad(r) end do end do do b = 1, min (size (p_par), size (i_par)) if (map(p_par(b)) == 0 .and. all (map /= i_par(b))) then map(p_par(b)) = i_par(b) end if end do end subroutine determine_map_for_radiation subroutine reconstruct_beam_and_radiation (k, i_set) integer, intent(in) :: k logical, dimension(:), intent(inout) :: i_set integer :: k_src, k_pre, k_in, k_rad type(interaction_t), pointer :: int_src integer, dimension(2) :: i_child logical, dimension(2) :: is_final integer :: i call int%find_source (k, int_src, k_src) k_pre = 0 k_in = k do while (.not. i_set (k_in)) if (k_pre == 0) then call int%set_momentum (int_src%get_momentum (k_src), k_in) else call int%set_momentum (int%get_momentum (k_pre), k_in) end if i_set(k_in) = .true. if (n_in == 2) then k_pre = k_in i_child = int%get_children (k_pre) do i = 1, 2 is_final(i) = int%get_n_children (i_child(i)) == 0 end do if (all (.not. is_final)) then k_in = i_child(k); k_rad = 0 else if (is_final(2)) then k_in = i_child(1); k_rad = i_child(2) else if (is_final(1)) then k_in = i_child(2); k_rad = i_child(1) else call err_beams end if if (k_rad /= 0) then if (i_set (k_in)) then call int%set_momentum & (int%get_momentum (k) - int%get_momentum (k_in), k_rad) i_set(k_rad) = .true. else call err_beams_norad end if end if end if end do end subroutine reconstruct_beam_and_radiation subroutine reconstruct_missing (i, i_set) integer, intent(in) :: i logical, dimension(:), intent(inout) :: i_set integer, dimension(:), allocatable :: i_child, i_parent, i_sibling integer :: s i_child = int%get_children (i) i_parent = int%get_parents (i) if (size (i_child) > 0 .and. all (i_set(i_child))) then call int%set_momentum (sum (int%get_momenta (i_child)), i) else if (size (i_parent) > 0 .and. all (i_set(i_parent))) then i_sibling = int%get_children (i_parent(1)) call int%set_momentum (sum (int%get_momenta (i_parent)), i) do s = 1, size (i_sibling) if (i_sibling(s) == i) cycle if (i_set(i_sibling(s))) then call int%set_momentum (int%get_momentum (i) & - int%get_momentum (i_sibling(s)), i) else call err_beams_norad end if end do else call err_beams_norad end if i_set(i) = .true. end subroutine reconstruct_missing 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_beams_norad call pset%write () call int%basic_write () call msg_fatal ("Reading particle set: Beam structure " & // "cannot be reconstructed for this configuration") end subroutine err_beams_norad 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. <>= procedure :: assign_vertices => particle_set_assign_vertices <>= module 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 end subroutine particle_set_assign_vertices <>= module 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. <>= procedure :: to_subevt => particle_set_to_subevt <>= module 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 end subroutine particle_set_to_subevt <>= module 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 (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 (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 (k, & particle_get_pdg (prt), & particle_get_momentum (prt), & particle_get_p2 (prt)) keep = .true. case (PRT_BEAM_REMNANT) if (prt%get_n_children () == 0) then k = k + 1 call subevt%set_outgoing (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 (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 <>= procedure :: replace => particle_set_replace <>= module subroutine particle_set_replace (particle_set, newprt) class(particle_set_t), intent(inout) :: particle_set type(particle_t), intent(in), dimension(:), allocatable :: newprt end subroutine particle_set_replace <>= module 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. <>= procedure :: order_color_lines => particle_set_order_color_lines <>= module 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 end subroutine particle_set_order_color_lines <>= module 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 <>= public :: pacify <>= interface pacify module procedure pacify_particle module procedure pacify_particle_set end interface pacify <>= module subroutine pacify_particle (prt) class(particle_t), intent(inout) :: prt end subroutine pacify_particle module subroutine pacify_particle_set (pset) class(particle_set_t), intent(inout) :: pset end subroutine pacify_particle_set <>= module 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 module 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]]>>= <> module particles_ut use unit_tests use particles_uti <> <> contains <> end module particles_ut @ %def particles_ut @ <<[[particles_uti.f90]]>>= <> module particles_uti <> 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 <> <> contains <> <> end module particles_uti @ %def particles_ut @ API: driver for the unit tests below. <>= public :: particles_test <>= subroutine particles_test (u, results) integer, intent(in) :: u type(test_results_t), intent(inout) :: results <> 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$. <>= call test (particles_1, "particles_1", & "check particle_set routines", & u, results) <>= public :: particles_1 <>= 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 (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. <>= call test (particles_2, "particles_2", & "reconstruct hard interaction", & u, results) <>= public :: particles_2 <>= 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. <>= call test (particles_3, "particles_3", & "reconstruct interaction with beam structure", & u, results) <>= public :: particles_3 <>= 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 @ <>= 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. <>= call test (particles_4, "particles_4", & "reconstruct interaction with missing beams", & u, results) <>= public :: particles_4 <>= 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). <>= call test (particles_5, "particles_5", & "reconstruct interaction with beams and duplicate entries", & u, results) <>= public :: particles_5 <>= 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. <>= call test (particles_6, "particles_6", & "reconstruct interaction with pair spectrum", & u, results) <>= public :: particles_6 <>= 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. <>= call test (particles_7, "particles_7", & "reconstruct decay interaction with reordering", & u, results) <>= public :: particles_7 <>= 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 @ <>= call test (particles_8, "particles_8", & "Test functions on particle sets", u, results) <>= public :: particles_8 <>= 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. <>= call test (particles_9, "particles_9", & "order into Lund strings, uncolored beam remnants", & u, results) <>= public :: particles_9 <>= 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/omega/tests/comparisons_UFO.list =================================================================== --- trunk/omega/tests/comparisons_UFO.list (revision 8839) +++ trunk/omega/tests/comparisons_UFO.list (revision 8840) @@ -1,105 +1,105 @@ ### comparisons_UFO.list -- #! ### -------------------------------------------------------------------- ### thr abs n roots model mode process ... ### -------------------------------------------------------------------- ### QCD uudd 0.75 1E-11 100 1000 SM scatter u ubar -> d dbar | u u~ -> d d~ uucc 0.75 1E-11 100 1000 SM scatter u ubar -> c cbar | u u~ -> c c~ uuga 0.30 1E-11 100 1000 SM scatter u ubar -> g A | u u~ -> g a ddga 0.30 1E-11 100 1000 SM scatter d dbar -> g A | d d~ -> g a uugg 0.25 1E-11 100 1000 SM scatter u ubar -> g g | u u~ -> g g ddgg 0.25 1E-11 100 1000 SM scatter d dbar -> g g | d d~ -> g g uugga 0.30 1E-11 100 1000 SM scatter u ubar -> g g A | u u~ -> g g a uuggg 0.30 1E-11 100 1000 SM scatter u ubar -> g g g | u u~ -> g g g ### -------------------------------------------------------------------- ### VB Higgs wwhh 0.65 1E-11 100 1000 SM scatter W+ W- -> H H whwh 0.65 1E-11 100 1000 SM scatter W+ H -> W+ H hhww 0.70 1E-11 100 1000 SM scatter H H -> W+ W- zzhh 0.70 1E-11 100 1000 SM scatter Z Z -> H H zhzh 0.70 1E-11 100 1000 SM scatter Z H -> Z H hhzz 0.70 1E-11 100 1000 SM scatter H H -> Z Z ### -------------------------------------------------------------------- ### Higgs hhhh 0.75 1E-11 100 1000 SM scatter H H -> H H hhhhh 0.75 1E-11 50 1000 SM scatter H H -> H H H hhhhhh 0.75 1E-11 50 1000 SM scatter H H -> H H H H ### -------------------------------------------------------------------- ### VBS wwww 0.50 1E-11 100 1000 SM scatter W+ W- -> W+ W- wwww_1 0.50 1E-11 100 1000 SM scatter W+ W+ -> W+ W+ wwww_2 0.50 1E-11 100 1000 SM scatter W+ W- -> W- W+ wwww_3 0.50 1E-11 100 1000 SM scatter W- W- -> W- W- aaww 0.55 1E-11 100 1000 SM scatter A A -> W+ W- | a a -> W+ W- awaw 0.55 1E-11 100 1000 SM scatter A W- -> A W- | a W- -> a W- awwa 0.55 1E-11 100 1000 SM scatter A W- -> W- A | a W- -> W- a wwaa 0.55 1E-11 100 1000 SM scatter W+ W- -> A A | W+ W- -> a a wwzz 0.50 1E-11 100 1000 SM scatter W+ W- -> Z Z wzwz 0.55 1E-11 100 1000 SM scatter W+ Z -> W+ Z wzwz_1 0.55 1E-11 100 1000 SM scatter W- Z -> W- Z wzzw 0.55 1E-11 100 1000 SM scatter W+ Z -> Z W+ wzzw_1 0.55 1E-11 100 1000 SM scatter W+ Z -> W+ Z wwaz 0.50 1E-11 100 1000 SM scatter W+ W- -> A Z | W+ W- -> a Z wwza 0.50 1E-11 100 1000 SM scatter W+ W- -> Z A | W+ W- -> Z a -zaww 0.55 1E-11 100 1000 SM scatter A Z -> W+ W- | a Z -> W+ W- +zaww 0.50 1E-11 100 1000 SM scatter A Z -> W+ W- | a Z -> W+ W- azww 0.55 1E-11 100 1000 SM scatter Z A -> W+ W- | Z a -> W+ W- wawz 0.55 1E-11 100 1000 SM scatter W+ A -> W+ Z | W+ a -> W+ Z wazw 0.55 1E-11 100 1000 SM scatter W+ A -> Z W+ | W+ a -> Z W+ wzwa 0.55 1E-11 100 1000 SM scatter W+ Z -> W+ A | W+ Z -> W+ a wzaw 0.55 1E-11 100 1000 SM scatter W+ Z -> A W+ | W+ Z -> a W+ ### -------------------------------------------------------------------- ### NC eemm 0.60 1E-11 100 1000 SM scatter e+ e- -> mu+ mu- emem 0.60 1E-11 100 1000 SM scatter e- mu- -> e- mu- eemmmm 0.60 1E-11 50 1000 SM scatter e+ e- -> mu+ mu- mu+ mu- eeee 0.60 1E-11 100 1000 SM scatter e+ e- -> e+ e- eeee_2 0.60 1E-11 100 1000 SM scatter e- e- -> e- e- eeee_3 0.60 1E-11 100 1000 SM scatter e+ e+ -> e+ e+ eeeeee 0.60 1E-11 50 1000 SM scatter e+ e- -> e+ e- e+ e- eaea 0.60 1E-11 100 1000 SM scatter e- A -> e- A | e- a -> e- a eeaa 0.60 1E-11 100 1000 SM scatter e+ e- -> A A | e+ e- -> a a aaee 0.60 1E-11 100 1000 SM scatter A A -> e+ e- | a a -> e+ e- eeaaa 0.60 1E-11 50 1000 SM scatter e+ e- -> A A A | e+ e- -> a a a eeaaaa 0.60 1E-11 50 1000 SM scatter e+ e- -> A A A A | e+ e- -> a a a a ezez 0.25 1E-11 100 1000 SM scatter e- Z -> e- Z eezz 0.30 1E-11 100 1000 SM scatter e+ e- -> Z Z zzee 0.25 1E-11 100 1000 SM scatter Z Z -> e+ e- eaez 0.25 1E-11 100 1000 SM scatter e- A -> e- Z | e- a -> e- Z eeaz 0.25 1E-11 100 1000 SM scatter e+ e- -> A Z | e+ e- -> a Z azee 0.25 1E-11 100 1000 SM scatter A Z -> e+ e- | a Z -> e+ e- enuenu 0.60 1E-11 50 1000 SM scatter e- numu -> e- numu | e- vm -> e- vm eenunu 0.60 1E-11 50 1000 SM scatter e+ e- -> nue nuebar | e+ e- -> ve ve~ nu4 0.60 1E-11 100 1000 SM scatter nue nue -> nue nue | ve ve -> ve ve eedd 0.60 1E-11 100 1000 SM scatter e+ e- -> d dbar | e+ e- -> d d~ eded 0.60 1E-11 100 1000 SM scatter e+ d -> e+ d | e+ d -> e+ d eeuu 0.60 1E-11 100 1000 SM scatter e+ e- -> u ubar | e+ e- -> u u~ eueu 0.60 1E-11 100 1000 SM scatter e+ u -> e+ u | e+ u -> e+ u uuee 0.60 1E-11 100 1000 SM scatter u ubar -> e+ e-| u u~ -> e+ e- uuaa 0.45 1E-11 100 1000 SM scatter u ubar -> A A | u u~ -> a a uuaz 0.25 1E-11 100 1000 SM scatter u ubar -> A Z | u u~ -> a Z ### -------------------------------------------------------------------- ### CC enumunu 0.80 1E-11 50 1000 SM scatter e- nuebar -> mu- numubar | e- ve~ -> mu- vm~ emununu 0.75 1E-11 50 1000 SM scatter e- mu+ -> nue numubar | e- mu+ -> ve vm~ uuww 0.35 1E-11 50 1000 SM scatter u ubar -> W+ W- | u u~ -> W+ W- ### -------------------------------------------------------------------- ### CC/NC interferences enuwa 0.60 1E-11 50 1000 SM scatter e- nuebar -> W- A | e- ve~ -> W- a ewnua 0.75 1E-11 50 1000 SM scatter e- W+ -> nue A | e- W+ -> ve a wenua 0.75 1E-11 50 1000 SM scatter e+ W- -> nuebar A | e+ W- -> ve~ a enuwz 0.60 1E-11 50 1000 SM scatter e- nuebar -> W- Z | e- ve~ -> W- Z ewnuz 0.75 1E-11 50 1000 SM scatter e- W+ -> nue Z | e- W+ -> ve Z ### -------------------------------------------------------------------- ### Top Yukawa tthh 0.80 1E-11 100 1000 SM scatter t tbar -> H H | t t~ -> H H ttgh 0.80 1E-11 100 1000 SM scatter t tbar -> g H | t t~ -> g H tbwh 0.80 1E-11 100 1000 SM scatter t bbar -> W+ H | t b~ -> W+ H ### -------------------------------------------------------------------- ### Pure QCD ggg 0.70 1E-11 100 1000 SM decay g -> g g gggg 0.60 1E-11 50 1000 SM scatter g g -> g g ggggg 0.30 1E-11 50 1000 SM scatter g g -> g g g ### Other eenu2H 0.75 1E-11 50 1000 SM scatter e+ e- -> nue nuebar H | e+ e- -> ve ve~ H ### ---------------------------------------------------------------------- Index: trunk/omega/tests/comparisons_majorana_legacy.list =================================================================== --- trunk/omega/tests/comparisons_majorana_legacy.list (revision 8839) +++ trunk/omega/tests/comparisons_majorana_legacy.list (revision 8840) @@ -1,23 +1,23 @@ # comparisons_majorana_legacy.list -- ######################################################################## # NB: the *overall* sign of an apmplitude may change depending on wether # we compute with Fusion.Mixed23 or Fusion_vintage.Mixed23_Majorana ######################################################################## # ---------------------------------------------------------------------- # thr abs_thr n roots model sign process ... # ---------------------------------------------------------------------- eeee 0.90 1E-11 100 1000 SM .true. scatter e- e- -> e- e- eeeea 0.90 1E-11 100 1000 SM .true. scatter e- e- -> e- e- A -eeeeaa 0.90 1E-11 100 1000 SM .true. scatter e- e- -> e- e- A A +eeeeaa 0.80 1E-11 100 1000 SM .true. scatter e- e- -> e- e- A A eeeeep 0.80 1E-11 100 1000 SM .true. scatter e- e- -> e- e- e+ e- aaep 0.90 1E-11 100 1000 SM .false. scatter A A -> e+ e- aaepep 0.75 1E-11 100 1000 SM .false. scatter A A -> e+ e- e+ e- eaea 0.90 1E-11 100 1000 SM .false. scatter e- A -> e- A epaa 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> A A epep 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> e+ e- epepa 0.75 1E-11 100 1000 SM .true. scatter e+ e- -> e+ e- A -epepaa 0.80 1E-11 100 1000 SM .true. scatter e+ e- -> e+ e- A A +epepaa 0.75 1E-11 100 1000 SM .true. scatter e+ e- -> e+ e- A A epepep 0.80 1E-11 100 1000 SM .true. scatter e+ e- -> e+ e- e+ e- epepepa 0.70 1E-11 100 1000 SM .true. scatter e+ e- -> e+ e- e+ e- A epepepaa 0.70 1E-11 100 1000 SM .true. scatter e+ e- -> e+ e- e+ e- A A epepepep 0.70 1E-11 100 1000 SM .true. scatter e+ e- -> e+ e- e+ e- e+ e- Index: trunk/omega/tests/comparisons_majorana.list =================================================================== --- trunk/omega/tests/comparisons_majorana.list (revision 8839) +++ trunk/omega/tests/comparisons_majorana.list (revision 8840) @@ -1,61 +1,61 @@ # comparisons_majorana.list -- ######################################################################## # NB: the *overall* sign of an amplitude may change depending on whether # we compute with Fusion.Mixed23 or Fusion.Mixed23_Majorana ######################################################################## # ---------------------------------------------------------------------- # thr abs_thr n roots model sign process ... # ---------------------------------------------------------------------- pe_z 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> Z ep_z 0.90 1E-11 100 1000 SM .false. scatter e- e+ -> Z ze_e 0.90 1E-11 100 1000 SM .false. scatter Z e- -> e- ez_e 0.90 1E-11 100 1000 SM .false. scatter e- Z -> e- zp_p 0.90 1E-11 100 1000 SM .true. scatter Z e+ -> e+ pz_p 0.90 1E-11 100 1000 SM .true. scatter e+ Z -> e+ z_pe 0.90 1E-11 100 1000 SM .false. decay Z -> e+ e- z_ep 0.90 1E-11 100 1000 SM .true. decay Z -> e- e+ e_ze 0.90 1E-11 100 1000 SM .false. decay e- -> Z e- e_ez 0.90 1E-11 100 1000 SM .false. decay e- -> e- Z p_zp 0.90 1E-11 100 1000 SM .true. decay e+ -> Z e+ p_pz 0.90 1E-11 100 1000 SM .true. decay e+ -> e+ Z eeee 0.90 1E-11 100 1000 SM .true. scatter e- e- -> e- e- eeeea 0.90 1E-11 10 1000 SM .true. scatter e- e- -> e- e- A eeeeaa 0.90 1E-11 10 1000 SM .true. scatter e- e- -> e- e- A A eeeeep 0.80 1E-11 10 1000 SM .true. scatter e- e- -> e- e- e+ e- epep 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> e+ e- epepa 0.75 1E-11 10 1000 SM .true. scatter e+ e- -> e+ e- A epepaa 0.80 1E-11 10 1000 SM .true. scatter e+ e- -> e+ e- A A epepep 0.80 1E-11 10 1000 SM .true. scatter e+ e- -> e+ e- e+ e- epepepa 0.70 1E-11 10 1000 SM .true. scatter e+ e- -> e+ e- e+ e- A epepepaa 0.70 1E-11 10 1000 SM .true. scatter e+ e- -> e+ e- e+ e- A A epepepep 0.70 1E-11 10 1000 SM .true. scatter e+ e- -> e+ e- e+ e- e+ e- aaep 0.90 1E-11 100 1000 SM .true. scatter A A -> e- e+ aape 0.90 1E-11 100 1000 SM .false. scatter A A -> e+ e- eaea 0.90 1E-11 100 1000 SM .false. scatter e- A -> e- A epaa 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> A A aaepep 0.75 1E-11 10 1000 SM .false. scatter A A -> e+ e- e+ e- epvv 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> nuebar nue epvva 0.90 1E-11 10 1000 SM .true. scatter e+ e- -> nuebar nue A vvep 0.90 1E-11 100 1000 SM .true. scatter nuebar nue -> e+ e- vvepa 0.40 1E-11 10 1000 SM .true. scatter nuebar nue -> e+ e- A wwep 0.70 1E-11 100 1000 SM .false. scatter W+ W- -> e+ e- ewew 0.70 1E-11 100 1000 SM .false. scatter e- W+ -> e- W+ pwpw 0.70 1E-11 100 1000 SM .true. scatter e+ W+ -> e+ W+ -epww 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> W+ W- +epww 0.80 1E-11 100 1000 SM .true. scatter e+ e- -> W+ W- wwvv 0.70 1E-11 100 1000 SM .false. scatter W+ W- -> nuebar nue wwvv_ 0.70 1E-11 100 1000 SM .true. scatter W+ W- -> nue nuebar zzep 0.90 1E-11 100 1000 SM .false. scatter Z Z -> e+ e- ezez 0.90 1E-11 100 1000 SM .false. scatter e- Z -> e- Z epzz 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> Z Z zzvv 0.90 1E-11 100 1000 SM .false. scatter Z Z -> nuebar nue vvzz 0.90 1E-11 100 1000 SM .true. scatter nuebar nue -> Z Z azep 0.90 1E-11 100 1000 SM .false. scatter A Z -> e+ e- zaep 0.90 1E-11 100 1000 SM .false. scatter Z A -> e+ e- ezea 0.90 1E-11 100 1000 SM .false. scatter e- Z -> e- A eaez 0.90 1E-11 100 1000 SM .false. scatter e- A -> e- Z epaz 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> A Z epza 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> Z A -epwwz 0.90 1E-11 10 1000 SM .true. scatter e+ e- -> W+ W- Z -epwwww 0.90 1E-11 10 1000 SM .true. scatter e+ e- -> W+ W- W+ W- -epwwzz 0.90 1E-11 10 1000 SM .true. scatter e+ e- -> W+ W- Z Z -cc10 0.90 1E-11 10 1000 SM .true. scatter e+ e- -> mu- numubar u dbar +epwwz 0.80 1E-11 10 1000 SM .true. scatter e+ e- -> W+ W- Z +epwwww 0.75 1E-11 10 1000 SM .true. scatter e+ e- -> W+ W- W+ W- +epwwzz 0.75 1E-11 10 1000 SM .true. scatter e+ e- -> W+ W- Z Z +cc10 0.85 1E-11 10 1000 SM .true. scatter e+ e- -> mu- numubar u dbar Index: trunk/omega/tests/comparisons_majorana_UFO.list =================================================================== --- trunk/omega/tests/comparisons_majorana_UFO.list (revision 8839) +++ trunk/omega/tests/comparisons_majorana_UFO.list (revision 8840) @@ -1,61 +1,61 @@ # comparisons_majorana_UFO.list -- ######################################################################## # NB: the *overall* sign of an amplitude may change depending on whether # we compute with Fusion.Mixed23 or Fusion.Mixed23_Majorana ######################################################################## # ---------------------------------------------------------------------- # thr abs_thr n roots model sign process ... # ---------------------------------------------------------------------- pe_z 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> Z ep_z 0.90 1E-11 100 1000 SM .false. scatter e- e+ -> Z ze_e 0.90 1E-11 100 1000 SM .false. scatter Z e- -> e- ez_e 0.90 1E-11 100 1000 SM .false. scatter e- Z -> e- zp_p 0.90 1E-11 100 1000 SM .true. scatter Z e+ -> e+ pz_p 0.90 1E-11 100 1000 SM .true. scatter e+ Z -> e+ z_pe 0.90 1E-11 100 1000 SM .false. decay Z -> e+ e- z_ep 0.90 1E-11 100 1000 SM .true. decay Z -> e- e+ e_ze 0.90 1E-11 100 1000 SM .false. decay e- -> Z e- e_ez 0.90 1E-11 100 1000 SM .false. decay e- -> e- Z p_zp 0.90 1E-11 100 1000 SM .true. decay e+ -> Z e+ p_pz 0.90 1E-11 100 1000 SM .true. decay e+ -> e+ Z eeee 0.90 1E-11 100 1000 SM .true. scatter e- e- -> e- e- eeeea 0.80 1E-11 10 1000 SM .true. scatter e- e- -> e- e- a eeeeaa 0.80 1E-11 10 1000 SM .true. scatter e- e- -> e- e- a a eeeeep 0.80 1E-11 10 1000 SM .true. scatter e- e- -> e- e- e+ e- epep 0.65 1E-11 100 1000 SM .true. scatter e+ e- -> e+ e- epepa 0.80 1E-11 10 1000 SM .true. scatter e+ e- -> e+ e- a epepaa 0.75 1E-11 10 1000 SM .true. scatter e+ e- -> e+ e- a a epepep 0.80 1E-11 10 1000 SM .true. scatter e+ e- -> e+ e- e+ e- epepepa 0.70 1E-11 10 1000 SM .true. scatter e+ e- -> e+ e- e+ e- a epepepaa 0.70 1E-11 10 1000 SM .true. scatter e+ e- -> e+ e- e+ e- a a epepepep 0.70 1E-11 10 1000 SM .true. scatter e+ e- -> e+ e- e+ e- e+ e- aaep 0.90 1E-11 100 1000 SM .true. scatter a a -> e- e+ aape 0.90 1E-11 100 1000 SM .false. scatter a a -> e+ e- eaea 0.90 1E-11 100 1000 SM .false. scatter e- a -> e- a epaa 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> a a aaepep 0.75 1E-11 10 1000 SM .false. scatter a a -> e+ e- e+ e- epvv 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> ve~ ve epvva 0.90 1E-11 10 1000 SM .true. scatter e+ e- -> ve~ ve a vvep 0.90 1E-11 100 1000 SM .true. scatter ve~ ve -> e+ e- vvepa 0.40 1E-11 10 1000 SM .true. scatter ve~ ve -> e+ e- a wwep 0.70 1E-11 100 1000 SM .false. scatter W+ W- -> e+ e- ewew 0.70 1E-11 100 1000 SM .false. scatter e- W+ -> e- W+ pwpw 0.70 1E-11 100 1000 SM .true. scatter e+ W+ -> e+ W+ -epww 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> W+ W- +epww 0.80 1E-11 100 1000 SM .true. scatter e+ e- -> W+ W- wwvv 0.70 1E-11 100 1000 SM .false. scatter W+ W- -> ve~ ve wwvv_ 0.70 1E-11 100 1000 SM .true. scatter W+ W- -> ve ve~ -zzep 0.90 1E-11 100 1000 SM .false. scatter Z Z -> e+ e- -ezez 0.90 1E-11 100 1000 SM .false. scatter e- Z -> e- Z -epzz 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> Z Z +zzep 0.50 1E-11 100 1000 SM .false. scatter Z Z -> e+ e- +ezez 0.35 1E-11 100 1000 SM .false. scatter e- Z -> e- Z +epzz 0.35 1E-11 100 1000 SM .true. scatter e+ e- -> Z Z zzvv 0.90 1E-11 100 1000 SM .false. scatter Z Z -> ve~ ve vvzz 0.90 1E-11 100 1000 SM .true. scatter ve~ ve -> Z Z azep 0.90 1E-11 100 1000 SM .false. scatter a Z -> e+ e- -zaep 0.90 1E-11 100 1000 SM .false. scatter Z a -> e+ e- +zaep 0.30 1E-11 100 1000 SM .false. scatter Z a -> e+ e- ezea 0.90 1E-11 100 1000 SM .false. scatter e- Z -> e- a -eaez 0.90 1E-11 100 1000 SM .false. scatter e- a -> e- Z -epaz 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> a Z -epza 0.90 1E-11 100 1000 SM .true. scatter e+ e- -> Z a +eaez 0.40 1E-11 100 1000 SM .false. scatter e- a -> e- Z +epaz 0.30 1E-11 100 1000 SM .true. scatter e+ e- -> a Z +epza 0.85 1E-11 100 1000 SM .true. scatter e+ e- -> Z a epwwz 0.70 1E-11 10 1000 SM .true. scatter e+ e- -> W+ W- Z epwwww 0.70 1E-11 10 1000 SM .true. scatter e+ e- -> W+ W- W+ W- epwwzz 0.70 1E-11 10 1000 SM .true. scatter e+ e- -> W+ W- Z Z cc10 0.90 1E-11 10 1000 SM .true. scatter e+ e- -> mu- vm~ u d~ Index: trunk/share/tests/functional_tests/ref-output-quad/openloops_12.ref =================================================================== --- trunk/share/tests/functional_tests/ref-output-quad/openloops_12.ref (revision 8839) +++ trunk/share/tests/functional_tests/ref-output-quad/openloops_12.ref (revision 8840) @@ -1,11126 +1,11126 @@ ?openmp_logging = false ?vis_history = false ?integration_timer = false ?pacify = true | Switching to model 'SM', scheme 'GF_MW_MZ' $blha_ew_scheme = "alpha_qed" SM.mZ => 9.11880E+01 SM.mW => 8.04190E+01 SM.mH => 1.25000E+02 SM.GF => 1.16639E-05 SM.wZ => 0.00000E+00 SM.wtop => 0.00000E+00 SM.wW => 0.00000E+00 SM.wH => 0.00000E+00 SM.ms => 0.00000E+00 SM.mc => 0.00000E+00 SM.mb => 0.00000E+00 SM.mtop => 1.73200E+02 SM.me => 0.00000E+00 SM.mmu => 0.00000E+00 SM.mtau => 1.77700E+00 SM.alphas => 1.18000E-01 ?alphas_is_fixed = false ?alphas_from_mz = true ?alphas_from_lambda_qcd = false alphas_nf = 5 [user variable] jet = PDG(2, -2, 1, -1, 3, -3, 21) $exclude_gauge_splittings = "c:b:t" $method = "openloops" alpha_power = 2 alphas_power = 1 $openloops_allowed_libs = "ppllj" ?use_vamp_equivalences = false $integration_method = "vamp2" $rng_method = "rng_stream" openmp_num_threads = 1 jet_algorithm = 2 jet_r = 5.00000E-01 seed = 99 sqrts = 5.00000E+05 | Process library 'openloops_12_lib': recorded process 'openloops_12_p1' | Integrate: current process library needs compilation | Process library 'openloops_12_lib': compiling ... | Process library 'openloops_12_lib': writing makefile | Process library 'openloops_12_lib': removing old files | Process library 'openloops_12_lib': writing driver | Process library 'openloops_12_lib': creating source code | Process library 'openloops_12_lib': compiling sources | Process library 'openloops_12_lib': linking | Process library 'openloops_12_lib': loading | Process library 'openloops_12_lib': ... success. | Integrate: compilation done | QCD alpha: using a running strong coupling | RNG: Initializing RNG Stream random-number generator | RNG: Setting seed for random-number generator to 99 | Initializing integration for process openloops_12_p1: | Beam structure: [any particles] | Beam data (collision): | e- (mass = 0.0000000E+00 GeV) | e+ (mass = 0.0000000E+00 GeV) | sqrts = 5.000000000000E+05 GeV | Phase space: generating configuration ... Warning: Intermediate decay of zero-width particle Z may be possible. | Phase space: ... success. | Phase space: writing configuration file 'openloops_12_p1.i1.phs' | Phase space: generating configuration ... | Phase space: ... success. | Phase space: writing configuration file 'openloops_12_p1.i3.phs' | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | ------------------------------------------------------------------------ | Process [scattering]: 'openloops_12_p1' | Library name = 'openloops_12_lib' | Process index = 1 | Process components: | 1: 'openloops_12_p1_i1': e-, e+ => u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl [inactive] | 2: 'openloops_12_p1_i2': e-, e+ => d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl [openloops], [real] | 3: 'openloops_12_p1_i3': e-, e+ => u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl [inactive], [virtual] | 4: 'openloops_12_p1_i4': e-, e+ => u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl [inactive], [subtraction] | ------------------------------------------------------------------------ | Phase space: 2 channels, 5 dimensions | Phase space: found 2 channels, collected in 1 grove. | Phase space: no equivalences between channels used. | Phase space: wood | Phase space: 2 channels, 8 dimensions | Phase space: found 2 channels, collected in 1 grove. | Phase space: no equivalences between channels used. | Phase space: wood | Phase space: 2 channels, 5 dimensions | Phase space: found 2 channels, collected in 1 grove. | Phase space: no equivalences between channels used. | Phase space: wood | Applying user-defined cuts. | Using user-defined general scale. | Starting integration for process 'openloops_12_p1' part 'real' | Integrate: iterations = 1:100:"gw" | Integrator: 1 chains, 2 channels, 8 dimensions | Integrator: Write grid header and grids to 'openloops_12_p1.m2.vg2' | Integrator: Grid checkpoint after each iteration | Integrator: 100 initial calls, 20 max. bins, stratified = T | Integrator: VAMP2 |=============================================================================| | It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] | |=============================================================================| | VAMP2: Initialize new grids and write to file 'openloops_12_p1.m2.vg2'. | VAMP2: set chain: use chained weights. 1 100 9.645E-04 4.01E-04 41.60 4.16 5.0 |-----------------------------------------------------------------------------| 1 100 9.645E-04 4.01E-04 41.60 4.16 5.0 |=============================================================================| | Integrate: sum of all components |=============================================================================| | It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] | |=============================================================================| 1 0 9.645E-04 4.01E-04 41.60 0.00 5.0 |=============================================================================| n_events = 10 $sample_normalization = "sigma" ?unweighted = false ?negative_weights = true ?keep_failed_events = true ?fixed_order_nlo_events = true ?debug_decay = false ?debug_process = false ?debug_verbose = false ?sample_pacify = true ?write_raw = false | Starting simulation for process 'openloops_12_p1' | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | Simulate: activating fixed-order NLO events | QCD alpha: using a running strong coupling | RNG: Initializing RNG Stream random-number generator | RNG: Setting seed for random-number generator to 100 | Events: writing to ASCII file 'openloops_12_p1.debug' | Events: generating 40 weighted, unpolarized NLO events ... | Events: event normalization mode 'sigma' | ... event sample complete. | Events: closing ASCII file 'openloops_12_p1.debug' | There were no errors and 1 warning(s). | WHIZARD run finished. |=============================================================================| Total number of regions: 18 alr || flst_real || i_real || em || mul || nreg || ftuples || flst_born || i_born || corr 1 || [ 11,-11, -2, 2, -2, 2] || 1 || 5 || 4 || 4 || {(3,4),(3,6),(4,5),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 2 || [ 11,-11, -2, 2, 21, 21] || 2 || 3 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 3 || [ 11,-11, -2, 2, 21, 21] || 2 || 4 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 4 || [ 11,-11, -2, 2, 21, 21] || 2 || 5 || 1 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 5 || [ 11,-11, -2, 2, -3, 3] || 3 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 6 || [ 11,-11, -3, 3, -2, 2] || 4 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 7 || [ 11,-11, -2, 2, -1, 1] || 5 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 8 || [ 11,-11, -1, 1, -2, 2] || 6 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 9 || [ 11,-11, -3, 3, -3, 3] || 7 || 5 || 4 || 4 || {(3,4),(3,6),(4,5),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 10 || [ 11,-11, -3, 3, -1, 1] || 8 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 11 || [ 11,-11, -1, 1, -3, 3] || 9 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 12 || [ 11,-11, -3, 3, 21, 21] || 10 || 3 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 13 || [ 11,-11, -3, 3, 21, 21] || 10 || 4 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 14 || [ 11,-11, -3, 3, 21, 21] || 10 || 5 || 1 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 15 || [ 11,-11, -1, 1, -1, 1] || 11 || 5 || 4 || 4 || {(3,4),(3,6),(4,5),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 16 || [ 11,-11, -1, 1, 21, 21] || 12 || 3 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 17 || [ 11,-11, -1, 1, 21, 21] || 12 || 4 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 18 || [ 11,-11, -1, 1, 21, 21] || 12 || 5 || 1 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd ------------------------------------------------------------------------ Contents of openloops_12_p1.debug: ======================================================================== Event #1 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 3.89241E-10 Squared matrix el. (prc) = -2.49037E-07 Event weight (ref) = 1.60826E-08 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3913894726.0, 1013504363.0, 4004029631.0, 3745048320.0, 2602019895.0, 3943078012.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-3) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 691625295.0, 3378437961.0, 1571131719.0, 108026903.0, 3340318134.0, 3620710479.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.141170135E-12 +sqme_rad = 2.14117013XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.468486E+05 P = 4.791335E+04 -4.923417E+04 -2.370961E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.400985E+05 P = -4.639184E+04 4.815715E+04 2.305992E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.660191E+03 P = -3.451326E+03 2.749984E+03 -1.497770E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.392675E+03 P = 1.929819E+03 -1.672961E+03 7.994623E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.817300E+05 P = -8.851315E+04 7.882993E+04 -1.377572E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.479079E+05 P = -2.836791E+04 2.993464E+04 1.420419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 8.073434E+03 P = -1.964125E+03 1.092270E+03 7.754321E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.622888E+05 P = 1.188452E+05 -1.098568E+05 -1.203907E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => -2.49037E-07 sqme_ref* => 3.89241E-10 event_index* => 1 event_weight* => 0.00000E+00 event_weight_ref* => 1.60826E-08 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4999146E+05; 4.8621734E+04,-4.9735609E+04,-2.4012086E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.3708037E+05;-4.5711494E+04, 4.7675549E+04, 2.2769410E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2928173E+04;-2.9102400E+03, 2.0600599E+03, 1.2426758E+04| 0.0000000E+00| 5) + 5 prt(o:21| 1.292817XE+04;-2.910240XE+03, 2.060059XE+03, 1.242675XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #1 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 3.89241E-10 Squared matrix el. (prc) = 3.85037E-10 Event weight (ref) = 1.60826E-08 Event weight (prc) = 1.59089E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3913894726.0, 1013504363.0, 4004029631.0, 3745048320.0, 2602019895.0, 3943078012.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-3) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 691625295.0, 3378437961.0, 1571131719.0, 108026903.0, 3340318134.0, 3620710479.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.141170135E-12 +sqme_rad = 2.14117013XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.468486E+05 P = 4.791335E+04 -4.923417E+04 -2.370961E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.400985E+05 P = -4.639184E+04 4.815715E+04 2.305992E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.660191E+03 P = -3.451326E+03 2.749984E+03 -1.497770E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.392675E+03 P = 1.929819E+03 -1.672961E+03 7.994623E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.817300E+05 P = -8.851315E+04 7.882993E+04 -1.377572E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.479079E+05 P = -2.836791E+04 2.993464E+04 1.420419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 8.073434E+03 P = -1.964125E+03 1.092270E+03 7.754321E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.622888E+05 P = 1.188452E+05 -1.098568E+05 -1.203907E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.85037E-10 sqme_ref* => 3.89241E-10 event_index* => 1 event_weight* => 1.59089E-08 event_weight_ref* => 1.60826E-08 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.4684860E+05; 4.7913352E+04,-4.9234169E+04,-2.3709605E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.4009853E+05;-4.6391844E+04, 4.8157146E+04, 2.3059920E+05| 0.0000000E+00| 4) - 5 prt(o:21| 4.6601911E+03;-3.4513264E+03, 2.7499842E+03,-1.4977696E+03| 0.0000000E+00| 5) - 6 prt(o:21| 8.3926755E+03; 1.9298191E+03,-1.6729609E+03, 7.9946233E+03| 0.0000000E+00| 6) + 5 prt(o:21| 4.660191XE+03;-3.451326XE+03, 2.749984XE+03,-1.497769XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 8.392675XE+03; 1.929819XE+03,-1.672960XE+03, 7.994623XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #1 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 3.89241E-10 Squared matrix el. (prc) = 2.06251E-12 Event weight (ref) = 1.60826E-08 Event weight (prc) = 8.52183E-11 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3913894726.0, 1013504363.0, 4004029631.0, 3745048320.0, 2602019895.0, 3943078012.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-3) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 691625295.0, 3378437961.0, 1571131719.0, 108026903.0, 3340318134.0, 3620710479.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.141170135E-12 +sqme_rad = 2.14117013XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.468486E+05 P = 4.791335E+04 -4.923417E+04 -2.370961E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.400985E+05 P = -4.639184E+04 4.815715E+04 2.305992E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.660191E+03 P = -3.451326E+03 2.749984E+03 -1.497770E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.392675E+03 P = 1.929819E+03 -1.672961E+03 7.994623E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.817300E+05 P = -8.851315E+04 7.882993E+04 -1.377572E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.479079E+05 P = -2.836791E+04 2.993464E+04 1.420419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 8.073434E+03 P = -1.964125E+03 1.092270E+03 7.754321E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.622888E+05 P = 1.188452E+05 -1.098568E+05 -1.203907E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.06251E-12 sqme_ref* => 3.89241E-10 event_index* => 1 event_weight* => 8.52183E-11 event_weight_ref* => 1.60826E-08 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 1.8172996E+05;-8.8513148E+04, 7.8829927E+04,-1.3775719E+05| 0.0000000E+00| 3) 4 prt(o:1| 1.4790785E+05;-2.8367908E+04, 2.9934639E+04, 1.4204194E+05| 0.0000000E+00| 4) - 5 prt(o:21| 8.0734344E+03;-1.9641249E+03, 1.0922702E+03, 7.7543215E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.6228876E+05; 1.1884518E+05,-1.0985684E+05,-1.2039071E+04| 0.0000000E+00| 6) + 5 prt(o:21| 8.073434XE+03;-1.964124XE+03, 1.092270XE+03, 7.754321XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.622887XE+05; 1.188451XE+05,-1.098568XE+05,-1.203907XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #1 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 3.89241E-10 Squared matrix el. (prc) = 2.14117E-12 Event weight (ref) = 1.60826E-08 Event weight (prc) = 8.84686E-11 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3913894726.0, 1013504363.0, 4004029631.0, 3745048320.0, 2602019895.0, 3943078012.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-3) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 691625295.0, 3378437961.0, 1571131719.0, 108026903.0, 3340318134.0, 3620710479.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.141170135E-12 +sqme_rad = 2.14117013XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.468486E+05 P = 4.791335E+04 -4.923417E+04 -2.370961E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.400985E+05 P = -4.639184E+04 4.815715E+04 2.305992E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.660191E+03 P = -3.451326E+03 2.749984E+03 -1.497770E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.392675E+03 P = 1.929819E+03 -1.672961E+03 7.994623E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.817300E+05 P = -8.851315E+04 7.882993E+04 -1.377572E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.479079E+05 P = -2.836791E+04 2.993464E+04 1.420419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 8.073434E+03 P = -1.964125E+03 1.092270E+03 7.754321E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.622888E+05 P = 1.188452E+05 -1.098568E+05 -1.203907E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.14117E-12 sqme_ref* => 3.89241E-10 event_index* => 1 event_weight* => 8.84686E-11 event_weight_ref* => 1.60826E-08 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.6296668E+05; 3.1842380E+04,-3.2235307E+04,-1.5654100E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.6330218E+05;-1.0405869E+05, 1.1951161E+05, 3.9450809E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.9823968E+04;-4.2410282E+03, 3.4480271E+03, 1.9055564E+04| 0.0000000E+00| 5) - 6 prt(o:21| 1.5390717E+05; 7.6457341E+04,-9.0724330E+04, 9.8034629E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.982396XE+04;-4.241028XE+03, 3.448027XE+03, 1.905556XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 1.539071XE+05; 7.645734XE+04,-9.072433XE+04, 9.803462XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #2 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.99461E-09 Squared matrix el. (prc) = -5.90914E-08 Event weight (ref) = 6.26874E-05 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2566007711.0, 2240170159.0, 3022189282.0, 484554216.0, 1681294000.0, 1422185293.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3393932940.0, 2952039924.0, 1817149397.0, 3151505971.0, 2985798367.0, 2791898150.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 6.319084955E-11 +sqme_rad = 6.31908495XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487563E+05 P = 1.447377E+04 1.072132E+05 -2.239990E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383998E+05 P = -1.265869E+04 -1.014761E+05 2.153528E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.001283E+04 P = -1.661639E+03 -7.492873E+03 6.430601E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.831067E+03 P = -1.534389E+02 1.755770E+03 2.215551E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.174964E+05 P = -7.025912E+03 4.712115E+04 -2.122144E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.155529E+05 P = -1.119089E+04 -9.148298E+04 1.948555E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.163656E+04 P = -2.134855E+03 -6.459096E+03 9.440977E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.531409E+04 P = 2.035166E+04 5.082092E+04 7.917847E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => -5.90914E-08 sqme_ref* => 2.99461E-09 event_index* => 2 event_weight* => 0.00000E+00 event_weight_ref* => 6.26874E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4989224E+05; 1.4672701E+04, 1.0784194E+05,-2.2494657E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.3731786E+05;-1.2468913E+04,-1.0087620E+05, 2.1444879E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2789898E+04;-2.2037877E+03,-6.9657375E+03, 1.0497777E+04| 0.0000000E+00| 5) + 5 prt(o:21| 1.278989XE+04;-2.203787XE+03,-6.965737XE+03, 1.049777XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #2 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.99461E-09 Squared matrix el. (prc) = 2.87907E-09 Event weight (ref) = 6.26874E-05 Event weight (prc) = 6.02689E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2566007711.0, 2240170159.0, 3022189282.0, 484554216.0, 1681294000.0, 1422185293.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3393932940.0, 2952039924.0, 1817149397.0, 3151505971.0, 2985798367.0, 2791898150.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 6.319084955E-11 +sqme_rad = 6.31908495XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487563E+05 P = 1.447377E+04 1.072132E+05 -2.239990E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383998E+05 P = -1.265869E+04 -1.014761E+05 2.153528E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.001283E+04 P = -1.661639E+03 -7.492873E+03 6.430601E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.831067E+03 P = -1.534389E+02 1.755770E+03 2.215551E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.174964E+05 P = -7.025912E+03 4.712115E+04 -2.122144E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.155529E+05 P = -1.119089E+04 -9.148298E+04 1.948555E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.163656E+04 P = -2.134855E+03 -6.459096E+03 9.440977E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.531409E+04 P = 2.035166E+04 5.082092E+04 7.917847E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.87907E-09 sqme_ref* => 2.99461E-09 event_index* => 2 event_weight* => 6.02689E-05 event_weight_ref* => 6.26874E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.4875629E+05; 1.4473772E+04, 1.0721317E+05,-2.2399897E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.3839981E+05;-1.2658694E+04,-1.0147606E+05, 2.1535282E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.0012832E+04;-1.6616390E+03,-7.4928729E+03, 6.4306006E+03| 0.0000000E+00| 5) - 6 prt(o:21| 2.8310666E+03;-1.5343894E+02, 1.7557702E+03, 2.2155509E+03| 0.0000000E+00| 6) + 5 prt(o:21| 1.001283XE+04;-1.661639XE+03,-7.492872XE+03, 6.430600XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 2.831066XE+03;-1.534389XE+02, 1.755770XE+03, 2.215550XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #2 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.99461E-09 Squared matrix el. (prc) = 5.23412E-11 Event weight (ref) = 6.26874E-05 Event weight (prc) = 1.09568E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2566007711.0, 2240170159.0, 3022189282.0, 484554216.0, 1681294000.0, 1422185293.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3393932940.0, 2952039924.0, 1817149397.0, 3151505971.0, 2985798367.0, 2791898150.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 6.319084955E-11 +sqme_rad = 6.31908495XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487563E+05 P = 1.447377E+04 1.072132E+05 -2.239990E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383998E+05 P = -1.265869E+04 -1.014761E+05 2.153528E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.001283E+04 P = -1.661639E+03 -7.492873E+03 6.430601E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.831067E+03 P = -1.534389E+02 1.755770E+03 2.215551E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.174964E+05 P = -7.025912E+03 4.712115E+04 -2.122144E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.155529E+05 P = -1.119089E+04 -9.148298E+04 1.948555E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.163656E+04 P = -2.134855E+03 -6.459096E+03 9.440977E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.531409E+04 P = 2.035166E+04 5.082092E+04 7.917847E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 5.23412E-11 sqme_ref* => 2.99461E-09 event_index* => 2 event_weight* => 1.09568E-06 event_weight_ref* => 6.26874E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.1749644E+05;-7.0259125E+03, 4.7121148E+04,-2.1221437E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.1555290E+05;-1.1190894E+04,-9.1482976E+04, 1.9485554E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.1636562E+04;-2.1348553E+03,-6.4590957E+03, 9.4409767E+03| 0.0000000E+00| 5) - 6 prt(o:21| 5.5314091E+04; 2.0351662E+04, 5.0820923E+04, 7.9178466E+03| 0.0000000E+00| 6) + 5 prt(o:21| 1.163656XE+04;-2.134855XE+03,-6.459095XE+03, 9.440976XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 5.531409XE+04; 2.035166XE+04, 5.082092XE+04, 7.917846XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #2 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.99461E-09 Squared matrix el. (prc) = 6.31908E-11 Event weight (ref) = 6.26874E-05 Event weight (prc) = 1.32280E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2566007711.0, 2240170159.0, 3022189282.0, 484554216.0, 1681294000.0, 1422185293.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3393932940.0, 2952039924.0, 1817149397.0, 3151505971.0, 2985798367.0, 2791898150.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 6.319084955E-11 +sqme_rad = 6.31908495XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487563E+05 P = 1.447377E+04 1.072132E+05 -2.239990E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383998E+05 P = -1.265869E+04 -1.014761E+05 2.153528E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.001283E+04 P = -1.661639E+03 -7.492873E+03 6.430601E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.831067E+03 P = -1.534389E+02 1.755770E+03 2.215551E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.174964E+05 P = -7.025912E+03 4.712115E+04 -2.122144E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.155529E+05 P = -1.119089E+04 -9.148298E+04 1.948555E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.163656E+04 P = -2.134855E+03 -6.459096E+03 9.440977E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.531409E+04 P = 2.035166E+04 5.082092E+04 7.917847E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 6.31908E-11 sqme_ref* => 2.99461E-09 event_index* => 2 event_weight* => 1.32280E-06 event_weight_ref* => 6.26874E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.2814568E+05; 1.3530057E+04, 9.8597709E+04,-2.0529462E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.0533521E+05;-3.3094026E+03,-1.2980551E+05, 1.5906642E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.3988379E+04;-2.2677952E+03,-7.4835722E+03, 1.1598621E+04| 0.0000000E+00| 5) - 6 prt(o:21| 5.2530730E+04;-7.9528596E+03, 3.8691371E+04, 3.4629575E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.398837XE+04;-2.267795XE+03,-7.483572XE+03, 1.159862XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 5.253073XE+04;-7.952859XE+03, 3.869137XE+04, 3.462957XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #3 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 5.35571E-11 Squared matrix el. (prc) = -1.05790E-03 Event weight (ref) = 4.09767E-11 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 658726814.0, 695277609.0, 1316830081.0, 2131992430.0, 749504030.0, 880099028.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1100463693.0, 3654384047.0, 647619641.0, 459938003.0, 1733458346.0, 3954010958.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.923323087E-11 +sqme_rad = 1.92332308XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499931E+05 P = 5.475338E+04 2.208098E+05 -1.036419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499948E+05 P = -5.474673E+04 -2.208104E+05 1.036482E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 1.003499E+01 P = -5.807919E+00 1.109636E+00 -8.107880E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 2.067649E+00 P = -8.361985E-01 -4.993300E-01 1.823900E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.378699E+05 P = 5.893797E+04 1.889232E+05 -1.319714E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.194078E+05 P = -4.804633E+04 -1.937939E+05 9.096849E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.249769E+01 P = -8.422184E+00 2.221758E+00 -8.962297E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.270971E+04 P = -1.088321E+04 4.868496E+03 4.101186E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => -1.05790E-03 sqme_ref* => 5.35571E-11 event_index* => 3 event_weight* => 0.00000E+00 event_weight_ref* => 4.09767E-11 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4999283E+05; 5.4754444E+04, 2.2080972E+05,-1.0364090E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4999506E+05;-5.4745670E+04,-2.2081052E+05, 1.0364920E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2102572E+01;-8.7732797E+00, 8.0588417E-01,-8.2977324E+00| 0.0000000E+00| 5) + 5 prt(o:21| 1.210257XE+01;-8.773279XE+00, 8.058841XE-01,-8.297732XE+00| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #3 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 5.35571E-11 Squared matrix el. (prc) = 4.00259E-04 Event weight (ref) = 4.09767E-11 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 658726814.0, 695277609.0, 1316830081.0, 2131992430.0, 749504030.0, 880099028.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1100463693.0, 3654384047.0, 647619641.0, 459938003.0, 1733458346.0, 3954010958.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.923323087E-11 +sqme_rad = 1.92332308XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499931E+05 P = 5.475338E+04 2.208098E+05 -1.036419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499948E+05 P = -5.474673E+04 -2.208104E+05 1.036482E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 1.003499E+01 P = -5.807919E+00 1.109636E+00 -8.107880E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 2.067649E+00 P = -8.361985E-01 -4.993300E-01 1.823900E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.378699E+05 P = 5.893797E+04 1.889232E+05 -1.319714E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.194078E+05 P = -4.804633E+04 -1.937939E+05 9.096849E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.249769E+01 P = -8.422184E+00 2.221758E+00 -8.962297E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.270971E+04 P = -1.088321E+04 4.868496E+03 4.101186E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 4.00259E-04 sqme_ref* => 5.35571E-11 event_index* => 3 event_weight* => 0.00000E+00 event_weight_ref* => 4.09767E-11 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4999310E+05; 5.4753379E+04, 2.2080982E+05,-1.0364191E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4999479E+05;-5.4746735E+04,-2.2081043E+05, 1.0364819E+05| 0.0000000E+00| 4) 5 prt(o:-2| 1.0034986E+01;-5.8079193E+00, 1.1096365E+00,-8.1078801E+00| 0.0000000E+00| 5) 6 prt(o:2| 2.0676487E+00;-8.3619846E-01,-4.9933002E-01, 1.8239005E+00| 0.0000000E+00| 6) ======================================================================== ======================================================================== Event #3 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 5.35571E-11 Squared matrix el. (prc) = 3.43239E-11 Event weight (ref) = 4.09767E-11 Event weight (prc) = 2.62613E-11 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 658726814.0, 695277609.0, 1316830081.0, 2131992430.0, 749504030.0, 880099028.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1100463693.0, 3654384047.0, 647619641.0, 459938003.0, 1733458346.0, 3954010958.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.923323087E-11 +sqme_rad = 1.92332308XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499931E+05 P = 5.475338E+04 2.208098E+05 -1.036419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499948E+05 P = -5.474673E+04 -2.208104E+05 1.036482E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 1.003499E+01 P = -5.807919E+00 1.109636E+00 -8.107880E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 2.067649E+00 P = -8.361985E-01 -4.993300E-01 1.823900E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.378699E+05 P = 5.893797E+04 1.889232E+05 -1.319714E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.194078E+05 P = -4.804633E+04 -1.937939E+05 9.096849E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.249769E+01 P = -8.422184E+00 2.221758E+00 -8.962297E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.270971E+04 P = -1.088321E+04 4.868496E+03 4.101186E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.43239E-11 sqme_ref* => 5.35571E-11 event_index* => 3 event_weight* => 2.62613E-11 event_weight_ref* => 4.09767E-11 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.3786995E+05; 5.8937970E+04, 1.8892321E+05,-1.3197139E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.1940785E+05;-4.8046334E+04,-1.9379393E+05, 9.0968487E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.2497686E+01;-8.4221839E+00, 2.2217578E+00,-8.9622975E+00| 0.0000000E+00| 5) - 6 prt(o:21| 4.2709712E+04;-1.0883214E+04, 4.8684964E+03, 4.1011862E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.249768XE+01;-8.422183XE+00, 2.221757XE+00,-8.962297XE+00| 0.000000XE+00| 5) + 6 prt(o:21| 4.270971XE+04;-1.088321XE+04, 4.868496XE+03, 4.101186XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #3 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 5.35571E-11 Squared matrix el. (prc) = 1.92332E-11 Event weight (ref) = 4.09767E-11 Event weight (prc) = 1.47154E-11 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 658726814.0, 695277609.0, 1316830081.0, 2131992430.0, 749504030.0, 880099028.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1100463693.0, 3654384047.0, 647619641.0, 459938003.0, 1733458346.0, 3954010958.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.923323087E-11 +sqme_rad = 1.92332308XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499931E+05 P = 5.475338E+04 2.208098E+05 -1.036419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499948E+05 P = -5.474673E+04 -2.208104E+05 1.036482E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 1.003499E+01 P = -5.807919E+00 1.109636E+00 -8.107880E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 2.067649E+00 P = -8.361985E-01 -4.993300E-01 1.823900E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.378699E+05 P = 5.893797E+04 1.889232E+05 -1.319714E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.194078E+05 P = -4.804633E+04 -1.937939E+05 9.096849E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.249769E+01 P = -8.422184E+00 2.221758E+00 -8.962297E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.270971E+04 P = -1.088321E+04 4.868496E+03 4.101186E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.92332E-11 sqme_ref* => 5.35571E-11 event_index* => 3 event_weight* => 1.47154E-11 event_weight_ref* => 4.09767E-11 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.1940561E+05; 4.8056240E+04, 1.9379326E+05,-9.0959286E+04| 0.0000000E+00| 3) 4 prt(o:2| 2.3787238E+05;-6.6551890E+04,-2.1966410E+05, 6.2464380E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.1913813E+01;-9.1159878E+00,-5.7639049E-01,-7.6488881E+00| 0.0000000E+00| 5) - 6 prt(o:21| 4.2710093E+04; 1.8504766E+04, 2.5871413E+04, 2.8502555E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.191381XE+01;-9.115987XE+00,-5.763904XE-01,-7.648888XE+00| 0.000000XE+00| 5) + 6 prt(o:21| 4.271009XE+04; 1.850476XE+04, 2.587141XE+04, 2.850255XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #4 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.11517E-10 Squared matrix el. (prc) = -4.20084E-09 Event weight (ref) = 2.67265E-07 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 852933358.0, 3802412940.0, 3514872455.0, 1024477926.0, 3849273974.0, 775318609.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 598672993.0, 229519251.0, 2192350721.0, 2167080660.0, 1984333633.0, 1125498793.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.057479501E-12 +sqme_rad = 2.05747950XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.402098E+05 P = -9.916913E+04 -1.776598E+05 -1.276842E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.470398E+05 P = 1.040861E+05 1.818731E+05 1.308317E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 5.196862E+03 P = -1.974904E+03 -3.054029E+03 3.712147E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 7.553455E+03 P = -2.942054E+03 -1.159324E+03 -6.859662E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.595906E+05 P = -4.904747E+04 -1.427702E+05 5.177032E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.811710E+05 P = 7.791726E+04 1.327318E+05 9.557250E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.719717E+04 P = -1.057542E+04 -1.091231E+04 -8.051372E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.420413E+05 P = -1.829437E+04 2.095069E+04 -1.392914E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => -4.20084E-09 sqme_ref* => 2.11517E-10 event_index* => 4 event_weight* => 0.00000E+00 event_weight_ref* => 2.67265E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.3768493E+05;-9.7347450E+04,-1.7609878E+05,-1.2651805E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4967549E+05; 1.0597952E+05, 1.8349562E+05, 1.3204374E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2639582E+04;-8.6320673E+03,-7.3968406E+03,-5.5256857E+03| 0.0000000E+00| 5) + 5 prt(o:21| 1.263958XE+04;-8.632067XE+03,-7.396840XE+03,-5.525685XE+03| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #4 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.11517E-10 Squared matrix el. (prc) = 2.07646E-10 Event weight (ref) = 2.67265E-07 Event weight (prc) = 2.62373E-07 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 852933358.0, 3802412940.0, 3514872455.0, 1024477926.0, 3849273974.0, 775318609.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 598672993.0, 229519251.0, 2192350721.0, 2167080660.0, 1984333633.0, 1125498793.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.057479501E-12 +sqme_rad = 2.05747950XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.402098E+05 P = -9.916913E+04 -1.776598E+05 -1.276842E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.470398E+05 P = 1.040861E+05 1.818731E+05 1.308317E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 5.196862E+03 P = -1.974904E+03 -3.054029E+03 3.712147E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 7.553455E+03 P = -2.942054E+03 -1.159324E+03 -6.859662E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.595906E+05 P = -4.904747E+04 -1.427702E+05 5.177032E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.811710E+05 P = 7.791726E+04 1.327318E+05 9.557250E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.719717E+04 P = -1.057542E+04 -1.091231E+04 -8.051372E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.420413E+05 P = -1.829437E+04 2.095069E+04 -1.392914E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.07646E-10 sqme_ref* => 2.11517E-10 event_index* => 4 event_weight* => 2.62373E-07 event_weight_ref* => 2.67265E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-3| 2.4020984E+05;-9.9169134E+04,-1.7765979E+05,-1.2768418E+05| 0.0000000E+00| 3) 4 prt(o:3| 2.4703985E+05; 1.0408609E+05, 1.8187314E+05, 1.3083169E+05| 0.0000000E+00| 4) - 5 prt(o:21| 5.1968624E+03;-1.9749038E+03,-3.0540295E+03, 3.7121473E+03| 0.0000000E+00| 5) - 6 prt(o:21| 7.5534548E+03;-2.9420537E+03,-1.1593240E+03,-6.8596623E+03| 0.0000000E+00| 6) + 5 prt(o:21| 5.196862XE+03;-1.974903XE+03,-3.054029XE+03, 3.712147XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 7.553454XE+03;-2.942053XE+03,-1.159324XE+03,-6.859662XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #4 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.11517E-10 Squared matrix el. (prc) = 1.81416E-12 Event weight (ref) = 2.67265E-07 Event weight (prc) = 2.29231E-09 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 852933358.0, 3802412940.0, 3514872455.0, 1024477926.0, 3849273974.0, 775318609.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 598672993.0, 229519251.0, 2192350721.0, 2167080660.0, 1984333633.0, 1125498793.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.057479501E-12 +sqme_rad = 2.05747950XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.402098E+05 P = -9.916913E+04 -1.776598E+05 -1.276842E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.470398E+05 P = 1.040861E+05 1.818731E+05 1.308317E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 5.196862E+03 P = -1.974904E+03 -3.054029E+03 3.712147E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 7.553455E+03 P = -2.942054E+03 -1.159324E+03 -6.859662E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.595906E+05 P = -4.904747E+04 -1.427702E+05 5.177032E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.811710E+05 P = 7.791726E+04 1.327318E+05 9.557250E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.719717E+04 P = -1.057542E+04 -1.091231E+04 -8.051372E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.420413E+05 P = -1.829437E+04 2.095069E+04 -1.392914E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.81416E-12 sqme_ref* => 2.11517E-10 event_index* => 4 event_weight* => 2.29231E-09 event_weight_ref* => 2.67265E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.5959055E+05;-4.9047475E+04,-1.4277018E+05, 5.1770318E+04| 0.0000000E+00| 3) 4 prt(o:2| 1.8117101E+05; 7.7917264E+04, 1.3273180E+05, 9.5572504E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.7197168E+04;-1.0575419E+04,-1.0912310E+04,-8.0513721E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.4204127E+05;-1.8294370E+04, 2.0950687E+04,-1.3929145E+05| 0.0000000E+00| 6) + 5 prt(o:21| 1.719716XE+04;-1.057541XE+04,-1.091231XE+04,-8.051372XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.420412XE+05;-1.829437XE+04, 2.095068XE+04,-1.392914XE+05| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #4 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.11517E-10 Squared matrix el. (prc) = 2.05748E-12 Event weight (ref) = 2.67265E-07 Event weight (prc) = 2.59975E-09 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 852933358.0, 3802412940.0, 3514872455.0, 1024477926.0, 3849273974.0, 775318609.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 598672993.0, 229519251.0, 2192350721.0, 2167080660.0, 1984333633.0, 1125498793.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.057479501E-12 +sqme_rad = 2.05747950XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.402098E+05 P = -9.916913E+04 -1.776598E+05 -1.276842E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.470398E+05 P = 1.040861E+05 1.818731E+05 1.308317E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 5.196862E+03 P = -1.974904E+03 -3.054029E+03 3.712147E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 7.553455E+03 P = -2.942054E+03 -1.159324E+03 -6.859662E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.595906E+05 P = -4.904747E+04 -1.427702E+05 5.177032E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.811710E+05 P = 7.791726E+04 1.327318E+05 9.557250E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.719717E+04 P = -1.057542E+04 -1.091231E+04 -8.051372E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.420413E+05 P = -1.829437E+04 2.095069E+04 -1.392914E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.05748E-12 sqme_ref* => 2.11517E-10 event_index* => 4 event_weight* => 2.59975E-09 event_weight_ref* => 2.67265E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-3| 1.6814124E+05;-6.7822687E+04,-1.2497886E+05,-8.9732076E+04| 0.0000000E+00| 3) 4 prt(o:3| 1.7349319E+05;-1.1861907E+04, 3.5114759E+04, 1.6948786E+05| 0.0000000E+00| 4) - 5 prt(o:21| 9.1587010E+03;-7.0461933E+03,-4.6510182E+03,-3.5497876E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.4920687E+05; 8.6730787E+04, 9.4515117E+04,-7.6205995E+04| 0.0000000E+00| 6) + 5 prt(o:21| 9.158701XE+03;-7.046193XE+03,-4.651018XE+03,-3.549787XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.492068XE+05; 8.673078XE+04, 9.451511XE+04,-7.620599XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #5 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 9.37951E-07 Squared matrix el. (prc) = 7.86870E-07 Event weight (ref) = 6.19701E-04 Event weight (prc) = 5.19882E-04 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 1 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1095625977.0, 443063532.0, 2957163220.0, 222499157.0, 3835620558.0, 2328100909.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1106982763.0, 4232153153.0, 2882700880.0, 3746330306.0, 161521528.0, 2991739543.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906263E-12 +sqme_rad = 3.84890626XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.497695E+05 P = -3.002715E+04 1.512306E+05 -1.965005E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.490052E+05 P = 2.961243E+04 -1.507153E+05 1.959887E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.826715E+02 P = 3.602545E+02 1.245413E+02 -3.381796E+01 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.426673E+02 P = 5.446535E+01 -6.398884E+02 5.455864E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.362137E+05 P = -1.144984E+05 -7.433487E+03 -7.340993E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.908174E+05 P = 2.252490E+04 -1.154686E+05 1.502362E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.672594E+02 P = 5.723541E+02 -5.794190E+02 5.218000E+02 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.720017E+05 P = 9.140118E+04 1.234815E+05 -7.734808E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 7.86870E-07 sqme_ref* => 9.37951E-07 event_index* => 5 event_weight* => 5.19882E-04 event_weight_ref* => 6.19701E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4994724E+05;-3.0123578E+04, 1.5135046E+05,-1.9661951E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4882822E+05; 2.9516369E+04,-1.5059592E+05, 1.9587020E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2245368E+03; 6.0720914E+02,-7.5454193E+02, 7.4930231E+02| 0.0000000E+00| 5) + 5 prt(o:21| 1.224536XE+03; 6.072091XE+02,-7.545419XE+02, 7.493023XE+02| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #5 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 9.37951E-07 Squared matrix el. (prc) = 1.51075E-07 Event weight (ref) = 6.19701E-04 Event weight (prc) = 9.98147E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 1 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1095625977.0, 443063532.0, 2957163220.0, 222499157.0, 3835620558.0, 2328100909.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1106982763.0, 4232153153.0, 2882700880.0, 3746330306.0, 161521528.0, 2991739543.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906263E-12 +sqme_rad = 3.84890626XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.497695E+05 P = -3.002715E+04 1.512306E+05 -1.965005E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.490052E+05 P = 2.961243E+04 -1.507153E+05 1.959887E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.826715E+02 P = 3.602545E+02 1.245413E+02 -3.381796E+01 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.426673E+02 P = 5.446535E+01 -6.398884E+02 5.455864E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.362137E+05 P = -1.144984E+05 -7.433487E+03 -7.340993E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.908174E+05 P = 2.252490E+04 -1.154686E+05 1.502362E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.672594E+02 P = 5.723541E+02 -5.794190E+02 5.218000E+02 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.720017E+05 P = 9.140118E+04 1.234815E+05 -7.734808E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.51075E-07 sqme_ref* => 9.37951E-07 event_index* => 5 event_weight* => 9.98147E-05 event_weight_ref* => 6.19701E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-3| 2.4976947E+05;-3.0027152E+04, 1.5123064E+05,-1.9650052E+05| 0.0000000E+00| 3) 4 prt(o:3| 2.4900519E+05; 2.9612432E+04,-1.5071529E+05, 1.9598875E+05| 0.0000000E+00| 4) - 5 prt(o:21| 3.8267147E+02; 3.6025445E+02, 1.2454128E+02,-3.3817956E+01| 0.0000000E+00| 5) - 6 prt(o:21| 8.4266732E+02; 5.4465351E+01,-6.3988840E+02, 5.4558645E+02| 0.0000000E+00| 6) + 5 prt(o:21| 3.826714XE+02; 3.602544XE+02, 1.245412XE+02,-3.381795XE+01| 0.000000XE+00| 5) + 6 prt(o:21| 8.426673XE+02; 5.446535XE+01,-6.398884XE+02, 5.455864XE+02| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #5 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 9.37951E-07 Squared matrix el. (prc) = 2.69142E-12 Event weight (ref) = 6.19701E-04 Event weight (prc) = 1.77821E-09 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 1 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1095625977.0, 443063532.0, 2957163220.0, 222499157.0, 3835620558.0, 2328100909.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1106982763.0, 4232153153.0, 2882700880.0, 3746330306.0, 161521528.0, 2991739543.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906263E-12 +sqme_rad = 3.84890626XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.497695E+05 P = -3.002715E+04 1.512306E+05 -1.965005E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.490052E+05 P = 2.961243E+04 -1.507153E+05 1.959887E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.826715E+02 P = 3.602545E+02 1.245413E+02 -3.381796E+01 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.426673E+02 P = 5.446535E+01 -6.398884E+02 5.455864E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.362137E+05 P = -1.144984E+05 -7.433487E+03 -7.340993E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.908174E+05 P = 2.252490E+04 -1.154686E+05 1.502362E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.672594E+02 P = 5.723541E+02 -5.794190E+02 5.218000E+02 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.720017E+05 P = 9.140118E+04 1.234815E+05 -7.734808E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.69142E-12 sqme_ref* => 9.37951E-07 event_index* => 5 event_weight* => 1.77821E-09 event_weight_ref* => 6.19701E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 1.3621368E+05;-1.1449843E+05,-7.4334869E+03,-7.3409933E+04| 0.0000000E+00| 3) 4 prt(o:1| 1.9081740E+05; 2.2524901E+04,-1.1546856E+05, 1.5023622E+05| 0.0000000E+00| 4) - 5 prt(o:21| 9.6725943E+02; 5.7235408E+02,-5.7941900E+02, 5.2179998E+02| 0.0000000E+00| 5) - 6 prt(o:21| 1.7200166E+05; 9.1401178E+04, 1.2348146E+05,-7.7348083E+04| 0.0000000E+00| 6) + 5 prt(o:21| 9.672594XE+02; 5.723540XE+02,-5.794190XE+02, 5.217999XE+02| 0.000000XE+00| 5) + 6 prt(o:21| 1.720016XE+05; 9.140117XE+04, 1.234814XE+05,-7.734808XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #5 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 9.37951E-07 Squared matrix el. (prc) = 3.84891E-12 Event weight (ref) = 6.19701E-04 Event weight (prc) = 2.54296E-09 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 1 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1095625977.0, 443063532.0, 2957163220.0, 222499157.0, 3835620558.0, 2328100909.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1106982763.0, 4232153153.0, 2882700880.0, 3746330306.0, 161521528.0, 2991739543.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906263E-12 +sqme_rad = 3.84890626XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.497695E+05 P = -3.002715E+04 1.512306E+05 -1.965005E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.490052E+05 P = 2.961243E+04 -1.507153E+05 1.959887E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.826715E+02 P = 3.602545E+02 1.245413E+02 -3.381796E+01 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.426673E+02 P = 5.446535E+01 -6.398884E+02 5.455864E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.362137E+05 P = -1.144984E+05 -7.433487E+03 -7.340993E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.908174E+05 P = 2.252490E+04 -1.154686E+05 1.502362E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.672594E+02 P = 5.723541E+02 -5.794190E+02 5.218000E+02 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.720017E+05 P = 9.140118E+04 1.234815E+05 -7.734808E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.84891E-12 sqme_ref* => 9.37951E-07 event_index* => 5 event_weight* => 2.54296E-09 event_weight_ref* => 6.19701E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.9205144E+05;-2.3255875E+04, 1.1631065E+05,-1.5104553E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.3515152E+05; 1.2377883E+05,-4.4069566E+04, 3.1664006E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.5654284E+03; 6.5055916E+02,-9.7571875E+02, 1.0369724E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.7123161E+05;-1.0117351E+05,-7.1265365E+04, 1.1834455E+05| 0.0000000E+00| 6) + 5 prt(o:21| 1.565428XE+03; 6.505591XE+02,-9.757187XE+02, 1.036972XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.712316XE+05;-1.011735XE+05,-7.126536XE+04, 1.183445XE+05| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #6 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 0.00000E+00 Squared matrix el. (prc) = 0.00000E+00 Event weight (ref) = 0.00000E+00 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2643453732.0, 343801519.0, 3374377404.0, 2585822891.0, 2834629654.0, 677007669.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2714720639.0, 1946415819.0, 2496115977.0, 2267707328.0, 4192754391.0, 3326698294.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906263E-12 +sqme_rad = 3.84890626XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499853E+05 P = 1.706024E+03 5.494993E+04 -2.438652E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754291E+05 P = -1.752218E+03 -3.869184E+04 1.711001E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 3.061428E+04 P = 6.524800E+02 -5.947974E+03 3.002382E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 4.397135E+04 P = -6.062864E+02 -1.031012E+04 4.274124E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.026503E+05 P = -1.354547E+03 2.503842E+04 -9.954061E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.753888E+05 P = -1.752012E+03 -3.868300E+04 1.710608E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.456851E+04 P = 4.629753E+01 -1.626009E+04 7.277410E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.473923E+05 P = 3.060261E+03 2.990467E+04 -1.442943E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 0.00000E+00 sqme_ref* => 0.00000E+00 event_index* => 6 event_weight* => 0.00000E+00 event_weight_ref* => 0.00000E+00 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4999844E+05; 1.7060160E+03, 5.4952809E+04,-2.4387804E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.7541986E+05;-1.7522235E+03,-3.8689819E+04, 1.7109108E+05| 0.0000000E+00| 4) - 5 prt(o:21| 7.4581696E+04; 4.6207512E+01,-1.6262989E+04, 7.2786966E+04| 0.0000000E+00| 5) + 5 prt(o:21| 7.458169XE+04; 4.620751XE+01,-1.626298XE+04, 7.278696XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #6 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 0.00000E+00 Squared matrix el. (prc) = 0.00000E+00 Event weight (ref) = 0.00000E+00 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2643453732.0, 343801519.0, 3374377404.0, 2585822891.0, 2834629654.0, 677007669.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2714720639.0, 1946415819.0, 2496115977.0, 2267707328.0, 4192754391.0, 3326698294.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906263E-12 +sqme_rad = 3.84890626XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499853E+05 P = 1.706024E+03 5.494993E+04 -2.438652E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754291E+05 P = -1.752218E+03 -3.869184E+04 1.711001E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 3.061428E+04 P = 6.524800E+02 -5.947974E+03 3.002382E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 4.397135E+04 P = -6.062864E+02 -1.031012E+04 4.274124E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.026503E+05 P = -1.354547E+03 2.503842E+04 -9.954061E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.753888E+05 P = -1.752012E+03 -3.868300E+04 1.710608E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.456851E+04 P = 4.629753E+01 -1.626009E+04 7.277410E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.473923E+05 P = 3.060261E+03 2.990467E+04 -1.442943E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 0.00000E+00 sqme_ref* => 0.00000E+00 event_index* => 6 event_weight* => 0.00000E+00 event_weight_ref* => 0.00000E+00 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4998525E+05; 1.7060241E+03, 5.4949933E+04,-2.4386517E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.7542912E+05;-1.7522177E+03,-3.8691837E+04, 1.7110011E+05| 0.0000000E+00| 4) 5 prt(o:-2| 3.0614277E+04; 6.5247997E+02,-5.9479744E+03, 3.0023821E+04| 0.0000000E+00| 5) 6 prt(o:2| 4.3971353E+04;-6.0628636E+02,-1.0310121E+04, 4.2741241E+04| 0.0000000E+00| 6) ======================================================================== ======================================================================== Event #6 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 0.00000E+00 Squared matrix el. (prc) = 0.00000E+00 Event weight (ref) = 0.00000E+00 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2643453732.0, 343801519.0, 3374377404.0, 2585822891.0, 2834629654.0, 677007669.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2714720639.0, 1946415819.0, 2496115977.0, 2267707328.0, 4192754391.0, 3326698294.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906263E-12 +sqme_rad = 3.84890626XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499853E+05 P = 1.706024E+03 5.494993E+04 -2.438652E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754291E+05 P = -1.752218E+03 -3.869184E+04 1.711001E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 3.061428E+04 P = 6.524800E+02 -5.947974E+03 3.002382E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 4.397135E+04 P = -6.062864E+02 -1.031012E+04 4.274124E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.026503E+05 P = -1.354547E+03 2.503842E+04 -9.954061E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.753888E+05 P = -1.752012E+03 -3.868300E+04 1.710608E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.456851E+04 P = 4.629753E+01 -1.626009E+04 7.277410E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.473923E+05 P = 3.060261E+03 2.990467E+04 -1.442943E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 0.00000E+00 sqme_ref* => 0.00000E+00 event_index* => 6 event_weight* => 0.00000E+00 event_weight_ref* => 0.00000E+00 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.0265033E+05;-1.3545472E+03, 2.5038418E+04,-9.9540612E+04| 0.0000000E+00| 3) 4 prt(o:2| 1.7538884E+05;-1.7520118E+03,-3.8682999E+04, 1.7106081E+05| 0.0000000E+00| 4) 5 prt(o:-2| 7.4568505E+04; 4.6297530E+01,-1.6260090E+04, 7.2774098E+04| 0.0000000E+00| 5) 6 prt(o:2| 1.4739233E+05; 3.0602614E+03, 2.9904671E+04,-1.4429429E+05| 0.0000000E+00| 6) ======================================================================== ======================================================================== Event #6 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 0.00000E+00 Squared matrix el. (prc) = 0.00000E+00 Event weight (ref) = 0.00000E+00 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2643453732.0, 343801519.0, 3374377404.0, 2585822891.0, 2834629654.0, 677007669.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2714720639.0, 1946415819.0, 2496115977.0, 2267707328.0, 4192754391.0, 3326698294.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906263E-12 +sqme_rad = 3.84890626XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499853E+05 P = 1.706024E+03 5.494993E+04 -2.438652E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754291E+05 P = -1.752218E+03 -3.869184E+04 1.711001E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 3.061428E+04 P = 6.524800E+02 -5.947974E+03 3.002382E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 4.397135E+04 P = -6.062864E+02 -1.031012E+04 4.274124E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.026503E+05 P = -1.354547E+03 2.503842E+04 -9.954061E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.753888E+05 P = -1.752012E+03 -3.868300E+04 1.710608E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.456851E+04 P = 4.629753E+01 -1.626009E+04 7.277410E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.473923E+05 P = 3.060261E+03 2.990467E+04 -1.442943E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 0.00000E+00 sqme_ref* => 0.00000E+00 event_index* => 6 event_weight* => 0.00000E+00 event_weight_ref* => 0.00000E+00 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4996742E+05; 1.7057061E+03, 5.4945966E+04,-2.4384778E+05| 0.0000000E+00| 3) 4 prt(o:2| 7.2018820E+04; 8.5135921E+02,-1.4247092E+04, 7.0590410E+04| 0.0000000E+00| 4) 5 prt(o:-2| 7.4590952E+04; 4.6115051E+01,-1.6265031E+04, 7.2795994E+04| 0.0000000E+00| 5) 6 prt(o:2| 1.0342281E+05;-2.6031803E+03,-2.4433843E+04, 1.0046138E+05| 0.0000000E+00| 6) ======================================================================== ======================================================================== Event #7 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 8.55503E-11 Squared matrix el. (prc) = 3.55893E-11 Event weight (ref) = 7.63602E-07 Event weight (prc) = 3.17662E-07 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2042523454.0, 1790911384.0, 3715479539.0, 3582083863.0, 2240445629.0, 3470253870.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3203562530.0, 370100846.0, 1647107524.0, 1466280485.0, 4189984473.0, 360074395.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.501742440E-12 +sqme_rad = 1.50174244XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.244498E+05 P = 2.194884E+04 7.093818E+04 -2.118106E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.339690E+05 P = -3.866983E+04 -7.103777E+04 2.195445E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.909056E+04 P = 1.211138E+04 6.048845E+03 1.346014E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.249061E+04 P = 4.609609E+03 -5.949262E+03 -2.119400E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.604817E+05 P = -1.425889E+04 1.471368E+05 -6.246461E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.668286E+05 P = -4.465765E+04 -4.698808E+04 1.537192E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.984911E+04 P = 3.741068E+04 5.549687E+03 -3.247423E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.228405E+05 P = 2.150586E+04 -1.056984E+05 -5.878040E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.55893E-11 sqme_ref* => 8.55503E-11 event_index* => 7 event_weight* => 3.17662E-07 event_weight_ref* => 7.63602E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.1952077E+05; 1.2396103E+04, 7.0881292E+04,-2.0739226E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4028763E+05;-4.8874220E+04,-7.1098540E+04, 2.2426425E+05| 0.0000000E+00| 4) - 5 prt(o:21| 4.0191596E+04; 3.6478117E+04, 2.1724804E+02,-1.6871992E+04| 0.0000000E+00| 5) + 5 prt(o:21| 4.019159XE+04; 3.647811XE+04, 2.172480XE+02,-1.687199XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #7 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 8.55503E-11 Squared matrix el. (prc) = 4.70453E-11 Event weight (ref) = 7.63602E-07 Event weight (prc) = 4.19915E-07 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2042523454.0, 1790911384.0, 3715479539.0, 3582083863.0, 2240445629.0, 3470253870.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3203562530.0, 370100846.0, 1647107524.0, 1466280485.0, 4189984473.0, 360074395.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.501742440E-12 +sqme_rad = 1.50174244XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.244498E+05 P = 2.194884E+04 7.093818E+04 -2.118106E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.339690E+05 P = -3.866983E+04 -7.103777E+04 2.195445E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.909056E+04 P = 1.211138E+04 6.048845E+03 1.346014E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.249061E+04 P = 4.609609E+03 -5.949262E+03 -2.119400E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.604817E+05 P = -1.425889E+04 1.471368E+05 -6.246461E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.668286E+05 P = -4.465765E+04 -4.698808E+04 1.537192E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.984911E+04 P = 3.741068E+04 5.549687E+03 -3.247423E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.228405E+05 P = 2.150586E+04 -1.056984E+05 -5.878040E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 4.70453E-11 sqme_ref* => 8.55503E-11 event_index* => 7 event_weight* => 4.19915E-07 event_weight_ref* => 7.63602E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-3| 2.2444981E+05; 2.1948838E+04, 7.0938184E+04,-2.1181062E+05| 0.0000000E+00| 3) 4 prt(o:3| 2.3396901E+05;-3.8669832E+04,-7.1037767E+04, 2.1954448E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.9090562E+04; 1.2111384E+04, 6.0488448E+03, 1.3460141E+04| 0.0000000E+00| 5) - 6 prt(o:21| 2.2490614E+04; 4.6096094E+03,-5.9492617E+03,-2.1193996E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.909056XE+04; 1.211138XE+04, 6.048844XE+03, 1.346014XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 2.249061XE+04; 4.609609XE+03,-5.949261XE+03,-2.119399XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #7 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 8.55503E-11 Squared matrix el. (prc) = 1.41404E-12 Event weight (ref) = 7.63602E-07 Event weight (prc) = 1.26214E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2042523454.0, 1790911384.0, 3715479539.0, 3582083863.0, 2240445629.0, 3470253870.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3203562530.0, 370100846.0, 1647107524.0, 1466280485.0, 4189984473.0, 360074395.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.501742440E-12 +sqme_rad = 1.50174244XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.244498E+05 P = 2.194884E+04 7.093818E+04 -2.118106E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.339690E+05 P = -3.866983E+04 -7.103777E+04 2.195445E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.909056E+04 P = 1.211138E+04 6.048845E+03 1.346014E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.249061E+04 P = 4.609609E+03 -5.949262E+03 -2.119400E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.604817E+05 P = -1.425889E+04 1.471368E+05 -6.246461E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.668286E+05 P = -4.465765E+04 -4.698808E+04 1.537192E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.984911E+04 P = 3.741068E+04 5.549687E+03 -3.247423E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.228405E+05 P = 2.150586E+04 -1.056984E+05 -5.878040E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.41404E-12 sqme_ref* => 8.55503E-11 event_index* => 7 event_weight* => 1.26214E-08 event_weight_ref* => 7.63602E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 1.6048174E+05;-1.4258890E+04, 1.4713683E+05,-6.2464608E+04| 0.0000000E+00| 3) 4 prt(o:1| 1.6682862E+05;-4.4657654E+04,-4.6988084E+04, 1.5371923E+05| 0.0000000E+00| 4) - 5 prt(o:21| 4.9849108E+04; 3.7410683E+04, 5.5496867E+03,-3.2474226E+04| 0.0000000E+00| 5) - 6 prt(o:21| 1.2284053E+05; 2.1505860E+04,-1.0569843E+05,-5.8780399E+04| 0.0000000E+00| 6) + 5 prt(o:21| 4.984910XE+04; 3.741068XE+04, 5.549686XE+03,-3.247422XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 1.228405XE+05; 2.150586XE+04,-1.056984XE+05,-5.878039XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #7 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 8.55503E-11 Squared matrix el. (prc) = 1.50174E-12 Event weight (ref) = 7.63602E-07 Event weight (prc) = 1.34042E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2042523454.0, 1790911384.0, 3715479539.0, 3582083863.0, 2240445629.0, 3470253870.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3203562530.0, 370100846.0, 1647107524.0, 1466280485.0, 4189984473.0, 360074395.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.501742440E-12 +sqme_rad = 1.50174244XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.244498E+05 P = 2.194884E+04 7.093818E+04 -2.118106E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.339690E+05 P = -3.866983E+04 -7.103777E+04 2.195445E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.909056E+04 P = 1.211138E+04 6.048845E+03 1.346014E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.249061E+04 P = 4.609609E+03 -5.949262E+03 -2.119400E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.604817E+05 P = -1.425889E+04 1.471368E+05 -6.246461E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.668286E+05 P = -4.465765E+04 -4.698808E+04 1.537192E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.984911E+04 P = 3.741068E+04 5.549687E+03 -3.247423E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.228405E+05 P = 2.150586E+04 -1.056984E+05 -5.878040E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.50174E-12 sqme_ref* => 8.55503E-11 event_index* => 7 event_weight* => 1.34042E-08 event_weight_ref* => 7.63602E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.4448132E+05;-3.1328617E+03, 4.8290923E+04,-1.3613605E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.8736022E+05; 7.5774962E+04, 3.3401761E+04, 1.6806644E+05| 0.0000000E+00| 4) - 5 prt(o:21| 3.3697108E+04; 3.3325896E+04,-4.3683660E+03,-2.4077104E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.3446135E+05;-1.0596800E+05,-7.7324317E+04,-2.9522682E+04| 0.0000000E+00| 6) + 5 prt(o:21| 3.369710XE+04; 3.332589XE+04,-4.368366XE+03,-2.407710XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.344613XE+05;-1.059680XE+05,-7.732431XE+04,-2.952268XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #8 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.79521E-07 Squared matrix el. (prc) = 1.56951E-07 Event weight (ref) = 1.57909E-05 Event weight (prc) = 1.38056E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3361222980.0, 3601284.0, 3842382860.0, 2580515999.0, 3568184670.0, 735623006.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2280904955.0, 1539004561.0, 852756080.0, 3258303332.0, 2415368508.0, 1295976056.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 4.950788936E-12 +sqme_rad = 4.95078893XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.497882E+05 P = 2.527464E+04 5.385094E+04 -2.426014E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.481274E+05 P = -2.453238E+04 -5.336726E+04 2.410754E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.027923E+02 P = 1.805539E+02 9.186084E+01 -9.305294E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.881521E+03 P = -9.228099E+02 -5.755396E+02 1.535349E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 8.895887E+04 P = 2.293156E+04 7.424874E+04 4.330067E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.837066E+05 P = -1.794896E+04 -3.946469E+04 1.785175E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.580182E+03 P = -8.209372E+02 -4.533780E+02 1.271804E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.257544E+05 P = -4.161665E+03 -3.433067E+04 -2.230899E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.56951E-07 sqme_ref* => 1.79521E-07 event_index* => 8 event_weight* => 1.38056E-05 event_weight_ref* => 1.57909E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4993875E+05; 2.5341874E+04, 5.3894751E+04,-2.4273963E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4797816E+05;-2.4465636E+04,-5.3323765E+04, 2.4093812E+05| 0.0000000E+00| 4) - 5 prt(o:21| 2.0830822E+03;-8.7623760E+02,-5.7098564E+02, 1.8015034E+03| 0.0000000E+00| 5) + 5 prt(o:21| 2.083082XE+03;-8.762376XE+02,-5.709856XE+02, 1.801503XE+03| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #8 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.79521E-07 Squared matrix el. (prc) = 2.25624E-08 Event weight (ref) = 1.57909E-05 Event weight (prc) = 1.98461E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3361222980.0, 3601284.0, 3842382860.0, 2580515999.0, 3568184670.0, 735623006.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2280904955.0, 1539004561.0, 852756080.0, 3258303332.0, 2415368508.0, 1295976056.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 4.950788936E-12 +sqme_rad = 4.95078893XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.497882E+05 P = 2.527464E+04 5.385094E+04 -2.426014E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.481274E+05 P = -2.453238E+04 -5.336726E+04 2.410754E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.027923E+02 P = 1.805539E+02 9.186084E+01 -9.305294E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.881521E+03 P = -9.228099E+02 -5.755396E+02 1.535349E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 8.895887E+04 P = 2.293156E+04 7.424874E+04 4.330067E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.837066E+05 P = -1.794896E+04 -3.946469E+04 1.785175E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.580182E+03 P = -8.209372E+02 -4.533780E+02 1.271804E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.257544E+05 P = -4.161665E+03 -3.433067E+04 -2.230899E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.25624E-08 sqme_ref* => 1.79521E-07 event_index* => 8 event_weight* => 1.98461E-06 event_weight_ref* => 1.57909E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4978825E+05; 2.5274639E+04, 5.3850938E+04,-2.4260139E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4812744E+05;-2.4532383E+04,-5.3367260E+04, 2.4107535E+05| 0.0000000E+00| 4) - 5 prt(o:21| 2.0279232E+02; 1.8055394E+02, 9.1860837E+01,-9.3052939E+00| 0.0000000E+00| 5) - 6 prt(o:21| 1.8815206E+03;-9.2280989E+02,-5.7553957E+02, 1.5353488E+03| 0.0000000E+00| 6) + 5 prt(o:21| 2.027923XE+02; 1.805539XE+02, 9.186083XE+01,-9.305293XE+00| 0.000000XE+00| 5) + 6 prt(o:21| 1.881520XE+03;-9.228098XE+02,-5.755395XE+02, 1.535348XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #8 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.79521E-07 Squared matrix el. (prc) = 2.44130E-12 Event weight (ref) = 1.57909E-05 Event weight (prc) = 2.14739E-10 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3361222980.0, 3601284.0, 3842382860.0, 2580515999.0, 3568184670.0, 735623006.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2280904955.0, 1539004561.0, 852756080.0, 3258303332.0, 2415368508.0, 1295976056.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 4.950788936E-12 +sqme_rad = 4.95078893XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.497882E+05 P = 2.527464E+04 5.385094E+04 -2.426014E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.481274E+05 P = -2.453238E+04 -5.336726E+04 2.410754E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.027923E+02 P = 1.805539E+02 9.186084E+01 -9.305294E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.881521E+03 P = -9.228099E+02 -5.755396E+02 1.535349E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 8.895887E+04 P = 2.293156E+04 7.424874E+04 4.330067E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.837066E+05 P = -1.794896E+04 -3.946469E+04 1.785175E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.580182E+03 P = -8.209372E+02 -4.533780E+02 1.271804E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.257544E+05 P = -4.161665E+03 -3.433067E+04 -2.230899E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.44130E-12 sqme_ref* => 1.79521E-07 event_index* => 8 event_weight* => 2.14739E-10 event_weight_ref* => 1.57909E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 8.8958866E+04; 2.2931558E+04, 7.4248739E+04, 4.3300672E+04| 0.0000000E+00| 3) 4 prt(o:2| 1.8370659E+05;-1.7948956E+04,-3.9464693E+04, 1.7851746E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.5801816E+03;-8.2093725E+02,-4.5337797E+02, 1.2718036E+03| 0.0000000E+00| 5) - 6 prt(o:21| 2.2575437E+05;-4.1616648E+03,-3.4330669E+04,-2.2308994E+05| 0.0000000E+00| 6) + 5 prt(o:21| 1.580181XE+03;-8.209372XE+02,-4.533779XE+02, 1.271803XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 2.257543XE+05;-4.161664XE+03,-3.433066XE+04,-2.230899XE+05| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #8 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.79521E-07 Squared matrix el. (prc) = 4.95079E-12 Event weight (ref) = 1.57909E-05 Event weight (prc) = 4.35477E-10 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3361222980.0, 3601284.0, 3842382860.0, 2580515999.0, 3568184670.0, 735623006.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2280904955.0, 1539004561.0, 852756080.0, 3258303332.0, 2415368508.0, 1295976056.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 4.950788936E-12 +sqme_rad = 4.95078893XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.497882E+05 P = 2.527464E+04 5.385094E+04 -2.426014E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.481274E+05 P = -2.453238E+04 -5.336726E+04 2.410754E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.027923E+02 P = 1.805539E+02 9.186084E+01 -9.305294E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.881521E+03 P = -9.228099E+02 -5.755396E+02 1.535349E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 8.895887E+04 P = 2.293156E+04 7.424874E+04 4.330067E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.837066E+05 P = -1.794896E+04 -3.946469E+04 1.785175E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.580182E+03 P = -8.209372E+02 -4.533780E+02 1.271804E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.257544E+05 P = -4.161665E+03 -3.433067E+04 -2.230899E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 4.95079E-12 sqme_ref* => 1.79521E-07 event_index* => 8 event_weight* => 4.35477E-10 event_weight_ref* => 1.57909E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 1.8682125E+05; 1.9114640E+04, 4.0322263E+04,-1.8141369E+05| 0.0000000E+00| 3) 4 prt(o:1| 8.6444859E+04; 4.5299272E+04, 7.3534261E+04,-3.6608858E+03| 0.0000000E+00| 4) - 5 prt(o:21| 2.7504015E+03;-9.4515241E+02,-7.2118804E+02, 2.4801780E+03| 0.0000000E+00| 5) - 6 prt(o:21| 2.2398349E+05;-6.3468759E+04,-1.1313534E+05, 1.8259440E+05| 0.0000000E+00| 6) + 5 prt(o:21| 2.750401XE+03;-9.451524XE+02,-7.211880XE+02, 2.480178XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 2.239834XE+05;-6.346875XE+04,-1.131353XE+05, 1.825944XE+05| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #9 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.02232E-08 Squared matrix el. (prc) = 2.86600E-07 Event weight (ref) = 1.47210E-06 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1484659988.0, 1927671876.0, 4126230753.0, 2962609785.0, 2346280463.0, 1525515485.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1981754768.0, 1371881432.0, 1113999651.0, 130493356.0, 4030926615.0, 1806134700.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.494556903E-10 +sqme_rad = 1.49455690XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487096E+05 P = 3.310905E+03 -8.615579E+04 -2.332867E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383402E+05 P = -3.704346E+03 8.193761E+04 2.237824E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.100863E+04 P = 2.291857E+03 4.527782E+03 9.769162E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.941646E+03 P = -1.898416E+03 -3.096039E+02 -2.648602E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.371521E+05 P = -3.308394E+04 -7.653858E+04 -2.220099E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.135808E+05 P = -3.442808E+03 7.328032E+04 2.005863E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.161504E+04 P = 5.041165E+02 4.781588E+03 1.057315E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.765212E+04 P = 3.602263E+04 -1.523326E+03 1.085044E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.86600E-07 sqme_ref* => 1.02232E-08 event_index* => 9 event_weight* => 0.00000E+00 event_weight_ref* => 1.47210E-06 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4997748E+05; 3.2628046E+03,-8.6671481E+04,-2.3444861E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.3713167E+05;-3.7502073E+03, 8.1445918E+04, 2.2267449E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2890846E+04; 4.8740273E+02, 5.2255632E+03, 1.1774117E+04| 0.0000000E+00| 5) + 5 prt(o:21| 1.289084XE+04; 4.874027XE+02, 5.225563XE+03, 1.177411XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #9 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.02232E-08 Squared matrix el. (prc) = 9.93345E-09 Event weight (ref) = 1.47210E-06 Event weight (prc) = 1.43037E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1484659988.0, 1927671876.0, 4126230753.0, 2962609785.0, 2346280463.0, 1525515485.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1981754768.0, 1371881432.0, 1113999651.0, 130493356.0, 4030926615.0, 1806134700.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.494556903E-10 +sqme_rad = 1.49455690XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487096E+05 P = 3.310905E+03 -8.615579E+04 -2.332867E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383402E+05 P = -3.704346E+03 8.193761E+04 2.237824E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.100863E+04 P = 2.291857E+03 4.527782E+03 9.769162E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.941646E+03 P = -1.898416E+03 -3.096039E+02 -2.648602E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.371521E+05 P = -3.308394E+04 -7.653858E+04 -2.220099E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.135808E+05 P = -3.442808E+03 7.328032E+04 2.005863E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.161504E+04 P = 5.041165E+02 4.781588E+03 1.057315E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.765212E+04 P = 3.602263E+04 -1.523326E+03 1.085044E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 9.93345E-09 sqme_ref* => 1.02232E-08 event_index* => 9 event_weight* => 1.43037E-06 event_weight_ref* => 1.47210E-06 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.4870956E+05; 3.3109049E+03,-8.6155785E+04,-2.3328665E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.3834017E+05;-3.7043461E+03, 8.1937607E+04, 2.2378235E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.1008630E+04; 2.2918569E+03, 4.5277823E+03, 9.7691618E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.9416457E+03;-1.8984158E+03,-3.0960385E+02,-2.6486017E+02| 0.0000000E+00| 6) + 5 prt(o:21| 1.100863XE+04; 2.291856XE+03, 4.527782XE+03, 9.769161XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.941645XE+03;-1.898415XE+03,-3.096038XE+02,-2.648601XE+02| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #9 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.02232E-08 Squared matrix el. (prc) = 1.40317E-10 Event weight (ref) = 1.47210E-06 Event weight (prc) = 2.02050E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1484659988.0, 1927671876.0, 4126230753.0, 2962609785.0, 2346280463.0, 1525515485.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1981754768.0, 1371881432.0, 1113999651.0, 130493356.0, 4030926615.0, 1806134700.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.494556903E-10 +sqme_rad = 1.49455690XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487096E+05 P = 3.310905E+03 -8.615579E+04 -2.332867E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383402E+05 P = -3.704346E+03 8.193761E+04 2.237824E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.100863E+04 P = 2.291857E+03 4.527782E+03 9.769162E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.941646E+03 P = -1.898416E+03 -3.096039E+02 -2.648602E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.371521E+05 P = -3.308394E+04 -7.653858E+04 -2.220099E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.135808E+05 P = -3.442808E+03 7.328032E+04 2.005863E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.161504E+04 P = 5.041165E+02 4.781588E+03 1.057315E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.765212E+04 P = 3.602263E+04 -1.523326E+03 1.085044E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.40317E-10 sqme_ref* => 1.02232E-08 event_index* => 9 event_weight* => 2.02050E-08 event_weight_ref* => 1.47210E-06 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.3715208E+05;-3.3083935E+04,-7.6538582E+04,-2.2200993E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.1358075E+05;-3.4428080E+03, 7.3280321E+04, 2.0058634E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.1615045E+04; 5.0411647E+02, 4.7815877E+03, 1.0573152E+04| 0.0000000E+00| 5) - 6 prt(o:21| 3.7652121E+04; 3.6022627E+04,-1.5233261E+03, 1.0850441E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.161504XE+04; 5.041164XE+02, 4.781587XE+03, 1.057315XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 3.765212XE+04; 3.602262XE+04,-1.523326XE+03, 1.085044XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #9 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.02232E-08 Squared matrix el. (prc) = 1.49456E-10 Event weight (ref) = 1.47210E-06 Event weight (prc) = 2.15209E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1484659988.0, 1927671876.0, 4126230753.0, 2962609785.0, 2346280463.0, 1525515485.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1981754768.0, 1371881432.0, 1113999651.0, 130493356.0, 4030926615.0, 1806134700.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.494556903E-10 +sqme_rad = 1.49455690XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487096E+05 P = 3.310905E+03 -8.615579E+04 -2.332867E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383402E+05 P = -3.704346E+03 8.193761E+04 2.237824E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.100863E+04 P = 2.291857E+03 4.527782E+03 9.769162E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.941646E+03 P = -1.898416E+03 -3.096039E+02 -2.648602E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.371521E+05 P = -3.308394E+04 -7.653858E+04 -2.220099E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.135808E+05 P = -3.442808E+03 7.328032E+04 2.005863E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.161504E+04 P = 5.041165E+02 4.781588E+03 1.057315E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.765212E+04 P = 3.602263E+04 -1.523326E+03 1.085044E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.49456E-10 sqme_ref* => 1.02232E-08 event_index* => 9 event_weight* => 2.15209E-08 event_weight_ref* => 1.47210E-06 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.2643462E+05; 2.8904732E+03,-7.8585296E+04,-2.1234084E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.2362168E+05; 3.0306470E+04, 8.3199455E+04, 2.0534367E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.4226444E+04; 4.6620970E+02, 5.6858273E+03, 1.3032487E+04| 0.0000000E+00| 5) - 6 prt(o:21| 3.5717259E+04;-3.3663153E+04,-1.0299987E+04,-6.0353138E+03| 0.0000000E+00| 6) + 5 prt(o:21| 1.422644XE+04; 4.662097XE+02, 5.685827XE+03, 1.303248XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 3.571725XE+04;-3.366315XE+04,-1.029998XE+04,-6.035313XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #10 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 4.92778E-09 Squared matrix el. (prc) = 7.74654E-07 Event weight (ref) = 1.03134E-04 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2574779949.0, 1613258.0, 957203242.0, 1832886249.0, 3404761797.0, 1098311093.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 379220129.0, 955940867.0, 625050135.0, 1046562733.0, 2664737320.0, 326107529.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 5.293057881E-10 +sqme_rad = 5.29305788XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.493156E+05 P = 1.186947E+05 2.140581E+05 4.742334E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.296477E+05 P = -1.116399E+05 -1.958949E+05 -4.358680E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982150E+04 P = -6.219397E+03 -1.857106E+04 -3.053953E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.215208E+03 P = -8.354423E+02 4.078269E+02 -7.825887E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.424422E+05 P = 1.046423E+05 2.116187E+05 5.518837E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.226841E+05 P = -1.083888E+05 -1.898795E+05 -4.225938E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.040489E+04 P = -7.175727E+03 -1.869021E+04 -3.942647E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.446880E+04 P = 1.092225E+04 -3.048961E+03 -8.986342E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 7.74654E-07 sqme_ref* => 4.92778E-09 event_index* => 10 event_weight* => 0.00000E+00 event_weight_ref* => 1.03134E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4989885E+05; 1.1890374E+05, 2.1459629E+05, 4.7537023E+04| 0.0000000E+00| 3) 4 prt(o:2| 2.2911259E+05;-1.1144776E+05,-1.9540027E+05,-4.3482329E+04| 0.0000000E+00| 4) - 5 prt(o:21| 2.0988556E+04;-7.4559875E+03,-1.9196021E+04,-4.0546932E+03| 0.0000000E+00| 5) + 5 prt(o:21| 2.098855XE+04;-7.455987XE+03,-1.919602XE+04,-4.054693XE+03| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #10 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 4.92778E-09 Squared matrix el. (prc) = 3.94883E-09 Event weight (ref) = 1.03134E-04 Event weight (prc) = 8.26455E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2574779949.0, 1613258.0, 957203242.0, 1832886249.0, 3404761797.0, 1098311093.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 379220129.0, 955940867.0, 625050135.0, 1046562733.0, 2664737320.0, 326107529.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 5.293057881E-10 +sqme_rad = 5.29305788XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.493156E+05 P = 1.186947E+05 2.140581E+05 4.742334E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.296477E+05 P = -1.116399E+05 -1.958949E+05 -4.358680E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982150E+04 P = -6.219397E+03 -1.857106E+04 -3.053953E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.215208E+03 P = -8.354423E+02 4.078269E+02 -7.825887E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.424422E+05 P = 1.046423E+05 2.116187E+05 5.518837E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.226841E+05 P = -1.083888E+05 -1.898795E+05 -4.225938E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.040489E+04 P = -7.175727E+03 -1.869021E+04 -3.942647E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.446880E+04 P = 1.092225E+04 -3.048961E+03 -8.986342E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.94883E-09 sqme_ref* => 4.92778E-09 event_index* => 10 event_weight* => 8.26455E-05 event_weight_ref* => 1.03134E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4931560E+05; 1.1869470E+05, 2.1405809E+05, 4.7423341E+04| 0.0000000E+00| 3) 4 prt(o:2| 2.2964769E+05;-1.1163986E+05,-1.9589486E+05,-4.3586799E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.9821498E+04;-6.2193968E+03,-1.8571060E+04,-3.0539532E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.2152085E+03;-8.3544227E+02, 4.0782685E+02,-7.8258868E+02| 0.0000000E+00| 6) + 5 prt(o:21| 1.982149XE+04;-6.219396XE+03,-1.857106XE+04,-3.053953XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.215208XE+03;-8.354422XE+02, 4.078268XE+02,-7.825886XE+02| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #10 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 4.92778E-09 Squared matrix el. (prc) = 4.49653E-10 Event weight (ref) = 1.03134E-04 Event weight (prc) = 9.41086E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2574779949.0, 1613258.0, 957203242.0, 1832886249.0, 3404761797.0, 1098311093.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 379220129.0, 955940867.0, 625050135.0, 1046562733.0, 2664737320.0, 326107529.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 5.293057881E-10 +sqme_rad = 5.29305788XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.493156E+05 P = 1.186947E+05 2.140581E+05 4.742334E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.296477E+05 P = -1.116399E+05 -1.958949E+05 -4.358680E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982150E+04 P = -6.219397E+03 -1.857106E+04 -3.053953E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.215208E+03 P = -8.354423E+02 4.078269E+02 -7.825887E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.424422E+05 P = 1.046423E+05 2.116187E+05 5.518837E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.226841E+05 P = -1.083888E+05 -1.898795E+05 -4.225938E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.040489E+04 P = -7.175727E+03 -1.869021E+04 -3.942647E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.446880E+04 P = 1.092225E+04 -3.048961E+03 -8.986342E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 4.49653E-10 sqme_ref* => 4.92778E-09 event_index* => 10 event_weight* => 9.41086E-06 event_weight_ref* => 1.03134E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4244221E+05; 1.0464228E+05, 2.1161867E+05, 5.5188366E+04| 0.0000000E+00| 3) 4 prt(o:2| 2.2268411E+05;-1.0838880E+05,-1.8987950E+05,-4.2259378E+04| 0.0000000E+00| 4) - 5 prt(o:21| 2.0404888E+04;-7.1757273E+03,-1.8690210E+04,-3.9426468E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.4468799E+04; 1.0922254E+04,-3.0489615E+03,-8.9863419E+03| 0.0000000E+00| 6) + 5 prt(o:21| 2.040488XE+04;-7.175727XE+03,-1.869021XE+04,-3.942646XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.446879XE+04; 1.092225XE+04,-3.048961XE+03,-8.986341XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #10 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 4.92778E-09 Squared matrix el. (prc) = 5.29306E-10 Event weight (ref) = 1.03134E-04 Event weight (prc) = 1.10779E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2574779949.0, 1613258.0, 957203242.0, 1832886249.0, 3404761797.0, 1098311093.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 379220129.0, 955940867.0, 625050135.0, 1046562733.0, 2664737320.0, 326107529.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 5.293057881E-10 +sqme_rad = 5.29305788XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.493156E+05 P = 1.186947E+05 2.140581E+05 4.742334E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.296477E+05 P = -1.116399E+05 -1.958949E+05 -4.358680E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982150E+04 P = -6.219397E+03 -1.857106E+04 -3.053953E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.215208E+03 P = -8.354423E+02 4.078269E+02 -7.825887E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.424422E+05 P = 1.046423E+05 2.116187E+05 5.518837E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.226841E+05 P = -1.083888E+05 -1.898795E+05 -4.225938E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.040489E+04 P = -7.175727E+03 -1.869021E+04 -3.942647E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.446880E+04 P = 1.092225E+04 -3.048961E+03 -8.986342E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 5.29306E-10 sqme_ref* => 4.92778E-09 event_index* => 10 event_weight* => 1.10779E-05 event_weight_ref* => 1.03134E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.4347085E+05; 1.1577672E+05, 2.0911371E+05, 4.6316987E+04| 0.0000000E+00| 3) 4 prt(o:1| 2.2172687E+05;-9.9680934E+04,-1.9518347E+05,-3.3614404E+04| 0.0000000E+00| 4) - 5 prt(o:21| 2.1536975E+04;-7.7255182E+03,-1.9668586E+04,-4.1598530E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.3265303E+04;-8.3702695E+03, 5.7383460E+03,-8.5427301E+03| 0.0000000E+00| 6) + 5 prt(o:21| 2.153697XE+04;-7.725518XE+03,-1.966858XE+04,-4.159853XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.326530XE+04;-8.370269XE+03, 5.738346XE+03,-8.542730XE+03| 0.000000XE+00| 6) ======================================================================== Index: trunk/share/tests/functional_tests/ref-output-double/openloops_12.ref =================================================================== --- trunk/share/tests/functional_tests/ref-output-double/openloops_12.ref (revision 8839) +++ trunk/share/tests/functional_tests/ref-output-double/openloops_12.ref (revision 8840) @@ -1,11126 +1,11126 @@ ?openmp_logging = false ?vis_history = false ?integration_timer = false ?pacify = true | Switching to model 'SM', scheme 'GF_MW_MZ' $blha_ew_scheme = "alpha_qed" SM.mZ => 9.11880E+01 SM.mW => 8.04190E+01 SM.mH => 1.25000E+02 SM.GF => 1.16639E-05 SM.wZ => 0.00000E+00 SM.wtop => 0.00000E+00 SM.wW => 0.00000E+00 SM.wH => 0.00000E+00 SM.ms => 0.00000E+00 SM.mc => 0.00000E+00 SM.mb => 0.00000E+00 SM.mtop => 1.73200E+02 SM.me => 0.00000E+00 SM.mmu => 0.00000E+00 SM.mtau => 1.77700E+00 SM.alphas => 1.18000E-01 ?alphas_is_fixed = false ?alphas_from_mz = true ?alphas_from_lambda_qcd = false alphas_nf = 5 [user variable] jet = PDG(2, -2, 1, -1, 3, -3, 21) $exclude_gauge_splittings = "c:b:t" $method = "openloops" alpha_power = 2 alphas_power = 1 $openloops_allowed_libs = "ppllj" ?use_vamp_equivalences = false $integration_method = "vamp2" $rng_method = "rng_stream" openmp_num_threads = 1 jet_algorithm = 2 jet_r = 5.00000E-01 seed = 99 sqrts = 5.00000E+05 | Process library 'openloops_12_lib': recorded process 'openloops_12_p1' | Integrate: current process library needs compilation | Process library 'openloops_12_lib': compiling ... | Process library 'openloops_12_lib': writing makefile | Process library 'openloops_12_lib': removing old files | Process library 'openloops_12_lib': writing driver | Process library 'openloops_12_lib': creating source code | Process library 'openloops_12_lib': compiling sources | Process library 'openloops_12_lib': linking | Process library 'openloops_12_lib': loading | Process library 'openloops_12_lib': ... success. | Integrate: compilation done | QCD alpha: using a running strong coupling | RNG: Initializing RNG Stream random-number generator | RNG: Setting seed for random-number generator to 99 | Initializing integration for process openloops_12_p1: | Beam structure: [any particles] | Beam data (collision): | e- (mass = 0.0000000E+00 GeV) | e+ (mass = 0.0000000E+00 GeV) | sqrts = 5.000000000000E+05 GeV | Phase space: generating configuration ... Warning: Intermediate decay of zero-width particle Z may be possible. | Phase space: ... success. | Phase space: writing configuration file 'openloops_12_p1.i1.phs' | Phase space: generating configuration ... | Phase space: ... success. | Phase space: writing configuration file 'openloops_12_p1.i3.phs' | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | ------------------------------------------------------------------------ | Process [scattering]: 'openloops_12_p1' | Library name = 'openloops_12_lib' | Process index = 1 | Process components: | 1: 'openloops_12_p1_i1': e-, e+ => u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl [inactive] | 2: 'openloops_12_p1_i2': e-, e+ => d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl [openloops], [real] | 3: 'openloops_12_p1_i3': e-, e+ => u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl [inactive], [virtual] | 4: 'openloops_12_p1_i4': e-, e+ => u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl [inactive], [subtraction] | ------------------------------------------------------------------------ | Phase space: 2 channels, 5 dimensions | Phase space: found 2 channels, collected in 1 grove. | Phase space: no equivalences between channels used. | Phase space: wood | Phase space: 2 channels, 8 dimensions | Phase space: found 2 channels, collected in 1 grove. | Phase space: no equivalences between channels used. | Phase space: wood | Phase space: 2 channels, 5 dimensions | Phase space: found 2 channels, collected in 1 grove. | Phase space: no equivalences between channels used. | Phase space: wood | Applying user-defined cuts. | Using user-defined general scale. | Starting integration for process 'openloops_12_p1' part 'real' | Integrate: iterations = 1:100:"gw" | Integrator: 1 chains, 2 channels, 8 dimensions | Integrator: Write grid header and grids to 'openloops_12_p1.m2.vg2' | Integrator: Grid checkpoint after each iteration | Integrator: 100 initial calls, 20 max. bins, stratified = T | Integrator: VAMP2 |=============================================================================| | It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] | |=============================================================================| | VAMP2: Initialize new grids and write to file 'openloops_12_p1.m2.vg2'. | VAMP2: set chain: use chained weights. 1 100 9.645E-04 4.01E-04 41.60 4.16 5.0 |-----------------------------------------------------------------------------| 1 100 9.645E-04 4.01E-04 41.60 4.16 5.0 |=============================================================================| | Integrate: sum of all components |=============================================================================| | It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] | |=============================================================================| 1 0 9.645E-04 4.01E-04 41.60 0.00 5.0 |=============================================================================| n_events = 10 $sample_normalization = "sigma" ?unweighted = false ?negative_weights = true ?keep_failed_events = true ?fixed_order_nlo_events = true ?debug_decay = false ?debug_process = false ?debug_verbose = false ?sample_pacify = true ?write_raw = false | Starting simulation for process 'openloops_12_p1' | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | Simulate: activating fixed-order NLO events | QCD alpha: using a running strong coupling | RNG: Initializing RNG Stream random-number generator | RNG: Setting seed for random-number generator to 100 | Events: writing to ASCII file 'openloops_12_p1.debug' | Events: generating 40 weighted, unpolarized NLO events ... | Events: event normalization mode 'sigma' | ... event sample complete. | Events: closing ASCII file 'openloops_12_p1.debug' | There were no errors and 1 warning(s). | WHIZARD run finished. |=============================================================================| Total number of regions: 18 alr || flst_real || i_real || em || mul || nreg || ftuples || flst_born || i_born || corr 1 || [ 11,-11, -2, 2, -2, 2] || 1 || 5 || 4 || 4 || {(3,4),(3,6),(4,5),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 2 || [ 11,-11, -2, 2, 21, 21] || 2 || 3 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 3 || [ 11,-11, -2, 2, 21, 21] || 2 || 4 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 4 || [ 11,-11, -2, 2, 21, 21] || 2 || 5 || 1 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 5 || [ 11,-11, -2, 2, -3, 3] || 3 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 6 || [ 11,-11, -3, 3, -2, 2] || 4 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 7 || [ 11,-11, -2, 2, -1, 1] || 5 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 8 || [ 11,-11, -1, 1, -2, 2] || 6 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 9 || [ 11,-11, -3, 3, -3, 3] || 7 || 5 || 4 || 4 || {(3,4),(3,6),(4,5),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 10 || [ 11,-11, -3, 3, -1, 1] || 8 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 11 || [ 11,-11, -1, 1, -3, 3] || 9 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 12 || [ 11,-11, -3, 3, 21, 21] || 10 || 3 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 13 || [ 11,-11, -3, 3, 21, 21] || 10 || 4 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 14 || [ 11,-11, -3, 3, 21, 21] || 10 || 5 || 1 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 15 || [ 11,-11, -1, 1, -1, 1] || 11 || 5 || 4 || 4 || {(3,4),(3,6),(4,5),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 16 || [ 11,-11, -1, 1, 21, 21] || 12 || 3 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 17 || [ 11,-11, -1, 1, 21, 21] || 12 || 4 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 18 || [ 11,-11, -1, 1, 21, 21] || 12 || 5 || 1 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd ------------------------------------------------------------------------ Contents of openloops_12_p1.debug: ======================================================================== Event #1 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 3.89241E-10 Squared matrix el. (prc) = -2.49037E-07 Event weight (ref) = 1.60830E-08 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3913894726.0, 1013504363.0, 4004029631.0, 3745048320.0, 2602019895.0, 3943078012.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-3) E = 2.499915E+05 P = 4.862150E+04 -4.973585E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.370804E+05 P = -4.571127E+04 4.767578E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292818E+04 P = -2.910232E+03 2.060075E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 691625295.0, 3378437961.0, 1571131719.0, 108026903.0, 3340318134.0, 3620710479.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184223E+04 -3.223547E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040581E+05 1.195121E+05 3.945076E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982398E+04 P = -4.241014E+03 3.448050E+03 1.905557E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645690E+04 -9.072468E+04 9.803467E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.141168897E-12 +sqme_rad = 2.14116889XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499915E+05 P = 4.862150E+04 -4.973585E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.370804E+05 P = -4.571127E+04 4.767578E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292818E+04 P = -2.910232E+03 2.060075E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.468486E+05 P = 4.791312E+04 -4.923441E+04 -2.370961E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.400985E+05 P = -4.639161E+04 4.815738E+04 2.305992E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.660192E+03 P = -3.451314E+03 2.750001E+03 -1.497771E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.392680E+03 P = 1.929811E+03 -1.672970E+03 7.994629E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.817299E+05 P = -8.851277E+04 7.883037E+04 -1.377572E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.479078E+05 P = -2.836777E+04 2.993478E+04 1.420419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 8.073438E+03 P = -1.964121E+03 1.092280E+03 7.754325E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.622888E+05 P = 1.188447E+05 -1.098574E+05 -1.203910E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184223E+04 -3.223547E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040581E+05 1.195121E+05 3.945076E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982398E+04 P = -4.241014E+03 3.448050E+03 1.905557E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645690E+04 -9.072468E+04 9.803467E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => -2.49037E-07 sqme_ref* => 3.89241E-10 event_index* => 1 event_weight* => 0.00000E+00 event_weight_ref* => 1.60830E-08 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4999146E+05; 4.8621499E+04,-4.9735851E+04,-2.4012085E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.3708036E+05;-4.5711267E+04, 4.7675776E+04, 2.2769409E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2928179E+04;-2.9102318E+03, 2.0600752E+03, 1.2426764E+04| 0.0000000E+00| 5) + 5 prt(o:21| 1.292817XE+04;-2.910231XE+03, 2.060075XE+03, 1.242676XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #1 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 3.89241E-10 Squared matrix el. (prc) = 3.85037E-10 Event weight (ref) = 1.60830E-08 Event weight (prc) = 1.59093E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3913894726.0, 1013504363.0, 4004029631.0, 3745048320.0, 2602019895.0, 3943078012.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-3) E = 2.499915E+05 P = 4.862150E+04 -4.973585E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.370804E+05 P = -4.571127E+04 4.767578E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292818E+04 P = -2.910232E+03 2.060075E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 691625295.0, 3378437961.0, 1571131719.0, 108026903.0, 3340318134.0, 3620710479.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184223E+04 -3.223547E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040581E+05 1.195121E+05 3.945076E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982398E+04 P = -4.241014E+03 3.448050E+03 1.905557E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645690E+04 -9.072468E+04 9.803467E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.141168897E-12 +sqme_rad = 2.14116889XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499915E+05 P = 4.862150E+04 -4.973585E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.370804E+05 P = -4.571127E+04 4.767578E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292818E+04 P = -2.910232E+03 2.060075E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.468486E+05 P = 4.791312E+04 -4.923441E+04 -2.370961E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.400985E+05 P = -4.639161E+04 4.815738E+04 2.305992E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.660192E+03 P = -3.451314E+03 2.750001E+03 -1.497771E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.392680E+03 P = 1.929811E+03 -1.672970E+03 7.994629E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.817299E+05 P = -8.851277E+04 7.883037E+04 -1.377572E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.479078E+05 P = -2.836777E+04 2.993478E+04 1.420419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 8.073438E+03 P = -1.964121E+03 1.092280E+03 7.754325E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.622888E+05 P = 1.188447E+05 -1.098574E+05 -1.203910E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184223E+04 -3.223547E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040581E+05 1.195121E+05 3.945076E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982398E+04 P = -4.241014E+03 3.448050E+03 1.905557E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645690E+04 -9.072468E+04 9.803467E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.85037E-10 sqme_ref* => 3.89241E-10 event_index* => 1 event_weight* => 1.59093E-08 event_weight_ref* => 1.60830E-08 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.4684860E+05; 4.7913118E+04,-4.9234407E+04,-2.3709605E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.4009853E+05;-4.6391615E+04, 4.8157376E+04, 2.3059919E+05| 0.0000000E+00| 4) - 5 prt(o:21| 4.6601923E+03;-3.4513140E+03, 2.7500011E+03,-1.4977711E+03| 0.0000000E+00| 5) - 6 prt(o:21| 8.3926803E+03; 1.9298108E+03,-1.6729697E+03, 7.9946285E+03| 0.0000000E+00| 6) + 5 prt(o:21| 4.660192XE+03;-3.451314XE+03, 2.750001XE+03,-1.497771XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 8.392680XE+03; 1.929810XE+03,-1.672969XE+03, 7.994628XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #1 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 3.89241E-10 Squared matrix el. (prc) = 2.06250E-12 Event weight (ref) = 1.60830E-08 Event weight (prc) = 8.52203E-11 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3913894726.0, 1013504363.0, 4004029631.0, 3745048320.0, 2602019895.0, 3943078012.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-3) E = 2.499915E+05 P = 4.862150E+04 -4.973585E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.370804E+05 P = -4.571127E+04 4.767578E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292818E+04 P = -2.910232E+03 2.060075E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 691625295.0, 3378437961.0, 1571131719.0, 108026903.0, 3340318134.0, 3620710479.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184223E+04 -3.223547E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040581E+05 1.195121E+05 3.945076E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982398E+04 P = -4.241014E+03 3.448050E+03 1.905557E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645690E+04 -9.072468E+04 9.803467E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.141168897E-12 +sqme_rad = 2.14116889XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499915E+05 P = 4.862150E+04 -4.973585E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.370804E+05 P = -4.571127E+04 4.767578E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292818E+04 P = -2.910232E+03 2.060075E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.468486E+05 P = 4.791312E+04 -4.923441E+04 -2.370961E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.400985E+05 P = -4.639161E+04 4.815738E+04 2.305992E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.660192E+03 P = -3.451314E+03 2.750001E+03 -1.497771E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.392680E+03 P = 1.929811E+03 -1.672970E+03 7.994629E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.817299E+05 P = -8.851277E+04 7.883037E+04 -1.377572E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.479078E+05 P = -2.836777E+04 2.993478E+04 1.420419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 8.073438E+03 P = -1.964121E+03 1.092280E+03 7.754325E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.622888E+05 P = 1.188447E+05 -1.098574E+05 -1.203910E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184223E+04 -3.223547E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040581E+05 1.195121E+05 3.945076E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982398E+04 P = -4.241014E+03 3.448050E+03 1.905557E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645690E+04 -9.072468E+04 9.803467E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.06250E-12 sqme_ref* => 3.89241E-10 event_index* => 1 event_weight* => 8.52203E-11 event_weight_ref* => 1.60830E-08 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 1.8172994E+05;-8.8512765E+04, 7.8830375E+04,-1.3775715E+05| 0.0000000E+00| 3) 4 prt(o:1| 1.4790785E+05;-2.8367765E+04, 2.9934780E+04, 1.4204193E+05| 0.0000000E+00| 4) - 5 prt(o:21| 8.0734380E+03;-1.9641208E+03, 1.0922803E+03, 7.7543249E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.6228878E+05; 1.1884465E+05,-1.0985743E+05,-1.2039099E+04| 0.0000000E+00| 6) + 5 prt(o:21| 8.073438XE+03;-1.964120XE+03, 1.092280XE+03, 7.754324XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.622887XE+05; 1.188446XE+05,-1.098574XE+05,-1.203909XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #1 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 3.89241E-10 Squared matrix el. (prc) = 2.14117E-12 Event weight (ref) = 1.60830E-08 Event weight (prc) = 8.84706E-11 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3913894726.0, 1013504363.0, 4004029631.0, 3745048320.0, 2602019895.0, 3943078012.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-3) E = 2.499915E+05 P = 4.862150E+04 -4.973585E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.370804E+05 P = -4.571127E+04 4.767578E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292818E+04 P = -2.910232E+03 2.060075E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 691625295.0, 3378437961.0, 1571131719.0, 108026903.0, 3340318134.0, 3620710479.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184223E+04 -3.223547E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040581E+05 1.195121E+05 3.945076E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982398E+04 P = -4.241014E+03 3.448050E+03 1.905557E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645690E+04 -9.072468E+04 9.803467E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.141168897E-12 +sqme_rad = 2.14116889XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499915E+05 P = 4.862150E+04 -4.973585E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.370804E+05 P = -4.571127E+04 4.767578E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292818E+04 P = -2.910232E+03 2.060075E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.468486E+05 P = 4.791312E+04 -4.923441E+04 -2.370961E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.400985E+05 P = -4.639161E+04 4.815738E+04 2.305992E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.660192E+03 P = -3.451314E+03 2.750001E+03 -1.497771E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.392680E+03 P = 1.929811E+03 -1.672970E+03 7.994629E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.817299E+05 P = -8.851277E+04 7.883037E+04 -1.377572E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.479078E+05 P = -2.836777E+04 2.993478E+04 1.420419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 8.073438E+03 P = -1.964121E+03 1.092280E+03 7.754325E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.622888E+05 P = 1.188447E+05 -1.098574E+05 -1.203910E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184223E+04 -3.223547E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040581E+05 1.195121E+05 3.945076E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982398E+04 P = -4.241014E+03 3.448050E+03 1.905557E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645690E+04 -9.072468E+04 9.803467E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.14117E-12 sqme_ref* => 3.89241E-10 event_index* => 1 event_weight* => 8.84706E-11 event_weight_ref* => 1.60830E-08 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.6296668E+05; 3.1842228E+04,-3.2235466E+04,-1.5654100E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.6330216E+05;-1.0405811E+05, 1.1951210E+05, 3.9450760E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.9823977E+04;-4.2410139E+03, 3.4480496E+03, 1.9055572E+04| 0.0000000E+00| 5) - 6 prt(o:21| 1.5390719E+05; 7.6456897E+04,-9.0724682E+04, 9.8034671E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.982397XE+04;-4.241013XE+03, 3.448049XE+03, 1.905557XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 1.539071XE+05; 7.645689XE+04,-9.072468XE+04, 9.803467XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #2 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.99460E-09 Squared matrix el. (prc) = -5.90912E-08 Event weight (ref) = 6.26895E-05 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2566007711.0, 2240170159.0, 3022189282.0, 484554216.0, 1681294000.0, 1422185293.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467123E+04 1.078422E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246754E+04 -1.008764E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203695E+03 -6.965772E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3393932940.0, 2952039924.0, 1817149397.0, 3151505971.0, 2985798367.0, 2791898150.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.352872E+04 9.859791E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.307599E+03 -1.298056E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398839E+04 P = -2.267695E+03 -7.483608E+03 1.159863E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253076E+04 P = -7.953421E+03 3.869128E+04 3.462960E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 6.319071901E-11 +sqme_rad = 6.31907190XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467123E+04 1.078422E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246754E+04 -1.008764E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203695E+03 -6.965772E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487563E+05 P = 1.447231E+04 1.072134E+05 -2.239990E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383998E+05 P = -1.265731E+04 -1.014763E+05 2.153528E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.001284E+04 P = -1.661536E+03 -7.492900E+03 6.430600E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.831070E+03 P = -1.534646E+02 1.755770E+03 2.215554E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.174964E+05 P = -7.026594E+03 4.712104E+04 -2.122143E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.155529E+05 P = -1.118965E+04 -9.148314E+04 1.948555E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.163657E+04 P = -2.134769E+03 -6.459129E+03 9.440979E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.531413E+04 P = 2.035101E+04 5.082122E+04 7.917848E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.352872E+04 9.859791E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.307599E+03 -1.298056E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398839E+04 P = -2.267695E+03 -7.483608E+03 1.159863E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253076E+04 P = -7.953421E+03 3.869128E+04 3.462960E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => -5.90912E-08 sqme_ref* => 2.99460E-09 event_index* => 2 event_weight* => 0.00000E+00 event_weight_ref* => 6.26895E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4989224E+05; 1.4671233E+04, 1.0784216E+05,-2.2494656E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.3731786E+05;-1.2467539E+04,-1.0087639E+05, 2.1444878E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2789904E+04;-2.2036947E+03,-6.9657720E+03, 1.0497780E+04| 0.0000000E+00| 5) + 5 prt(o:21| 1.278990XE+04;-2.203694XE+03,-6.965772XE+03, 1.049778XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #2 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.99460E-09 Squared matrix el. (prc) = 2.87907E-09 Event weight (ref) = 6.26895E-05 Event weight (prc) = 6.02709E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2566007711.0, 2240170159.0, 3022189282.0, 484554216.0, 1681294000.0, 1422185293.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467123E+04 1.078422E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246754E+04 -1.008764E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203695E+03 -6.965772E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3393932940.0, 2952039924.0, 1817149397.0, 3151505971.0, 2985798367.0, 2791898150.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.352872E+04 9.859791E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.307599E+03 -1.298056E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398839E+04 P = -2.267695E+03 -7.483608E+03 1.159863E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253076E+04 P = -7.953421E+03 3.869128E+04 3.462960E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 6.319071901E-11 +sqme_rad = 6.31907190XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467123E+04 1.078422E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246754E+04 -1.008764E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203695E+03 -6.965772E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487563E+05 P = 1.447231E+04 1.072134E+05 -2.239990E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383998E+05 P = -1.265731E+04 -1.014763E+05 2.153528E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.001284E+04 P = -1.661536E+03 -7.492900E+03 6.430600E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.831070E+03 P = -1.534646E+02 1.755770E+03 2.215554E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.174964E+05 P = -7.026594E+03 4.712104E+04 -2.122143E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.155529E+05 P = -1.118965E+04 -9.148314E+04 1.948555E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.163657E+04 P = -2.134769E+03 -6.459129E+03 9.440979E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.531413E+04 P = 2.035101E+04 5.082122E+04 7.917848E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.352872E+04 9.859791E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.307599E+03 -1.298056E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398839E+04 P = -2.267695E+03 -7.483608E+03 1.159863E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253076E+04 P = -7.953421E+03 3.869128E+04 3.462960E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.87907E-09 sqme_ref* => 2.99460E-09 event_index* => 2 event_weight* => 6.02709E-05 event_weight_ref* => 6.26895E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.4875629E+05; 1.4472313E+04, 1.0721338E+05,-2.2399896E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.3839981E+05;-1.2657312E+04,-1.0147625E+05, 2.1535281E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.0012835E+04;-1.6615365E+03,-7.4928999E+03, 6.4305999E+03| 0.0000000E+00| 5) - 6 prt(o:21| 2.8310697E+03;-1.5346459E+02, 1.7557696E+03, 2.2155535E+03| 0.0000000E+00| 6) + 5 prt(o:21| 1.001283XE+04;-1.661536XE+03,-7.492899XE+03, 6.430599XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 2.831069XE+03;-1.534645XE+02, 1.755769XE+03, 2.215553XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #2 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.99460E-09 Squared matrix el. (prc) = 5.23411E-11 Event weight (ref) = 6.26895E-05 Event weight (prc) = 1.09572E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2566007711.0, 2240170159.0, 3022189282.0, 484554216.0, 1681294000.0, 1422185293.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467123E+04 1.078422E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246754E+04 -1.008764E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203695E+03 -6.965772E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3393932940.0, 2952039924.0, 1817149397.0, 3151505971.0, 2985798367.0, 2791898150.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.352872E+04 9.859791E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.307599E+03 -1.298056E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398839E+04 P = -2.267695E+03 -7.483608E+03 1.159863E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253076E+04 P = -7.953421E+03 3.869128E+04 3.462960E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 6.319071901E-11 +sqme_rad = 6.31907190XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467123E+04 1.078422E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246754E+04 -1.008764E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203695E+03 -6.965772E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487563E+05 P = 1.447231E+04 1.072134E+05 -2.239990E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383998E+05 P = -1.265731E+04 -1.014763E+05 2.153528E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.001284E+04 P = -1.661536E+03 -7.492900E+03 6.430600E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.831070E+03 P = -1.534646E+02 1.755770E+03 2.215554E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.174964E+05 P = -7.026594E+03 4.712104E+04 -2.122143E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.155529E+05 P = -1.118965E+04 -9.148314E+04 1.948555E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.163657E+04 P = -2.134769E+03 -6.459129E+03 9.440979E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.531413E+04 P = 2.035101E+04 5.082122E+04 7.917848E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.352872E+04 9.859791E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.307599E+03 -1.298056E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398839E+04 P = -2.267695E+03 -7.483608E+03 1.159863E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253076E+04 P = -7.953421E+03 3.869128E+04 3.462960E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 5.23411E-11 sqme_ref* => 2.99460E-09 event_index* => 2 event_weight* => 1.09572E-06 event_weight_ref* => 6.26895E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.1749642E+05;-7.0265939E+03, 4.7121042E+04,-2.1221435E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.1555288E+05;-1.1189647E+04,-9.1483136E+04, 1.9485552E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.1636566E+04;-2.1347691E+03,-6.4591286E+03, 9.4409793E+03| 0.0000000E+00| 5) - 6 prt(o:21| 5.5314126E+04; 2.0351010E+04, 5.0821222E+04, 7.9178480E+03| 0.0000000E+00| 6) + 5 prt(o:21| 1.163656XE+04;-2.134769XE+03,-6.459128XE+03, 9.440979XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 5.531412XE+04; 2.035101XE+04, 5.082122XE+04, 7.917848XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #2 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.99460E-09 Squared matrix el. (prc) = 6.31907E-11 Event weight (ref) = 6.26895E-05 Event weight (prc) = 1.32285E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2566007711.0, 2240170159.0, 3022189282.0, 484554216.0, 1681294000.0, 1422185293.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467123E+04 1.078422E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246754E+04 -1.008764E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203695E+03 -6.965772E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3393932940.0, 2952039924.0, 1817149397.0, 3151505971.0, 2985798367.0, 2791898150.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.352872E+04 9.859791E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.307599E+03 -1.298056E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398839E+04 P = -2.267695E+03 -7.483608E+03 1.159863E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253076E+04 P = -7.953421E+03 3.869128E+04 3.462960E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 6.319071901E-11 +sqme_rad = 6.31907190XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467123E+04 1.078422E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246754E+04 -1.008764E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203695E+03 -6.965772E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487563E+05 P = 1.447231E+04 1.072134E+05 -2.239990E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383998E+05 P = -1.265731E+04 -1.014763E+05 2.153528E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.001284E+04 P = -1.661536E+03 -7.492900E+03 6.430600E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.831070E+03 P = -1.534646E+02 1.755770E+03 2.215554E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.174964E+05 P = -7.026594E+03 4.712104E+04 -2.122143E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.155529E+05 P = -1.118965E+04 -9.148314E+04 1.948555E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.163657E+04 P = -2.134769E+03 -6.459129E+03 9.440979E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.531413E+04 P = 2.035101E+04 5.082122E+04 7.917848E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.352872E+04 9.859791E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.307599E+03 -1.298056E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398839E+04 P = -2.267695E+03 -7.483608E+03 1.159863E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253076E+04 P = -7.953421E+03 3.869128E+04 3.462960E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 6.31907E-11 sqme_ref* => 2.99460E-09 event_index* => 2 event_weight* => 1.32285E-06 event_weight_ref* => 6.26895E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.2814567E+05; 1.3528715E+04, 9.8597905E+04,-2.0529460E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.0533519E+05;-3.3075988E+03,-1.2980557E+05, 1.5906637E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.3988386E+04;-2.2676952E+03,-7.4836082E+03, 1.1598626E+04| 0.0000000E+00| 5) - 6 prt(o:21| 5.2530762E+04;-7.9534211E+03, 3.8691276E+04, 3.4629599E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.398838XE+04;-2.267695XE+03,-7.483608XE+03, 1.159862XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 5.253076XE+04;-7.953421XE+03, 3.869127XE+04, 3.462959XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #3 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 5.35570E-11 Squared matrix el. (prc) = -1.05790E-03 Event weight (ref) = 4.09774E-11 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 658726814.0, 695277609.0, 1316830081.0, 2131992430.0, 749504030.0, 880099028.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499928E+05 P = 5.475198E+04 2.208103E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.499951E+05 P = -5.474321E+04 -2.208111E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210258E+01 P = -8.773290E+00 8.057940E-01 -8.297738E+00 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1100463693.0, 3654384047.0, 647619641.0, 459938003.0, 1733458346.0, 3954010958.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805407E+04 1.937938E+05 -9.095926E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.654943E+04 -2.196648E+05 6.246431E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191382E+01 P = -9.115983E+00 -5.764865E-01 -7.648893E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271014E+04 P = 1.850448E+04 2.587164E+04 2.850260E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.923316838E-11 +sqme_rad = 1.92331683XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499928E+05 P = 5.475198E+04 2.208103E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499951E+05 P = -5.474321E+04 -2.208111E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210258E+01 P = -8.773290E+00 8.057940E-01 -8.297738E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499931E+05 P = 5.475092E+04 2.208104E+05 -1.036419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499948E+05 P = -5.474427E+04 -2.208110E+05 1.036482E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 1.003499E+01 P = -5.807928E+00 1.109576E+00 -8.107885E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 2.067652E+00 P = -8.361955E-01 -4.993384E-01 1.823903E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.378699E+05 P = 5.893585E+04 1.889238E+05 -1.319714E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.194078E+05 P = -4.804417E+04 -1.937944E+05 9.096846E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.249769E+01 P = -8.422210E+00 2.221674E+00 -8.962304E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.270975E+04 P = -1.088326E+04 4.868384E+03 4.101191E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805407E+04 1.937938E+05 -9.095926E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.654943E+04 -2.196648E+05 6.246431E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191382E+01 P = -9.115983E+00 -5.764865E-01 -7.648893E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271014E+04 P = 1.850448E+04 2.587164E+04 2.850260E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => -1.05790E-03 sqme_ref* => 5.35570E-11 event_index* => 3 event_weight* => 0.00000E+00 event_weight_ref* => 4.09774E-11 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4999283E+05; 5.4751981E+04, 2.2081034E+05,-1.0364088E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4999506E+05;-5.4743208E+04,-2.2081114E+05, 1.0364918E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2102578E+01;-8.7732902E+00, 8.0579400E-01,-8.2977382E+00| 0.0000000E+00| 5) + 5 prt(o:21| 1.210257XE+01;-8.773290XE+00, 8.057940XE-01,-8.297738XE+00| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #3 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 5.35570E-11 Squared matrix el. (prc) = 4.00258E-04 Event weight (ref) = 4.09774E-11 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 658726814.0, 695277609.0, 1316830081.0, 2131992430.0, 749504030.0, 880099028.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499928E+05 P = 5.475198E+04 2.208103E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.499951E+05 P = -5.474321E+04 -2.208111E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210258E+01 P = -8.773290E+00 8.057940E-01 -8.297738E+00 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1100463693.0, 3654384047.0, 647619641.0, 459938003.0, 1733458346.0, 3954010958.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805407E+04 1.937938E+05 -9.095926E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.654943E+04 -2.196648E+05 6.246431E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191382E+01 P = -9.115983E+00 -5.764865E-01 -7.648893E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271014E+04 P = 1.850448E+04 2.587164E+04 2.850260E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.923316838E-11 +sqme_rad = 1.92331683XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499928E+05 P = 5.475198E+04 2.208103E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499951E+05 P = -5.474321E+04 -2.208111E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210258E+01 P = -8.773290E+00 8.057940E-01 -8.297738E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499931E+05 P = 5.475092E+04 2.208104E+05 -1.036419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499948E+05 P = -5.474427E+04 -2.208110E+05 1.036482E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 1.003499E+01 P = -5.807928E+00 1.109576E+00 -8.107885E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 2.067652E+00 P = -8.361955E-01 -4.993384E-01 1.823903E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.378699E+05 P = 5.893585E+04 1.889238E+05 -1.319714E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.194078E+05 P = -4.804417E+04 -1.937944E+05 9.096846E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.249769E+01 P = -8.422210E+00 2.221674E+00 -8.962304E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.270975E+04 P = -1.088326E+04 4.868384E+03 4.101191E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805407E+04 1.937938E+05 -9.095926E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.654943E+04 -2.196648E+05 6.246431E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191382E+01 P = -9.115983E+00 -5.764865E-01 -7.648893E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271014E+04 P = 1.850448E+04 2.587164E+04 2.850260E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 4.00258E-04 sqme_ref* => 5.35570E-11 event_index* => 3 event_weight* => 0.00000E+00 event_weight_ref* => 4.09774E-11 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4999310E+05; 5.4750916E+04, 2.2081043E+05,-1.0364189E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4999479E+05;-5.4744272E+04,-2.2081104E+05, 1.0364817E+05| 0.0000000E+00| 4) 5 prt(o:-2| 1.0034988E+01;-5.8079282E+00, 1.1095764E+00,-8.1078851E+00| 0.0000000E+00| 5) 6 prt(o:2| 2.0676517E+00;-8.3619554E-01,-4.9933844E-01, 1.8239029E+00| 0.0000000E+00| 6) ======================================================================== ======================================================================== Event #3 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 5.35570E-11 Squared matrix el. (prc) = 3.43238E-11 Event weight (ref) = 4.09774E-11 Event weight (prc) = 2.62618E-11 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 658726814.0, 695277609.0, 1316830081.0, 2131992430.0, 749504030.0, 880099028.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499928E+05 P = 5.475198E+04 2.208103E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.499951E+05 P = -5.474321E+04 -2.208111E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210258E+01 P = -8.773290E+00 8.057940E-01 -8.297738E+00 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1100463693.0, 3654384047.0, 647619641.0, 459938003.0, 1733458346.0, 3954010958.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805407E+04 1.937938E+05 -9.095926E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.654943E+04 -2.196648E+05 6.246431E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191382E+01 P = -9.115983E+00 -5.764865E-01 -7.648893E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271014E+04 P = 1.850448E+04 2.587164E+04 2.850260E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.923316838E-11 +sqme_rad = 1.92331683XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499928E+05 P = 5.475198E+04 2.208103E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499951E+05 P = -5.474321E+04 -2.208111E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210258E+01 P = -8.773290E+00 8.057940E-01 -8.297738E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499931E+05 P = 5.475092E+04 2.208104E+05 -1.036419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499948E+05 P = -5.474427E+04 -2.208110E+05 1.036482E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 1.003499E+01 P = -5.807928E+00 1.109576E+00 -8.107885E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 2.067652E+00 P = -8.361955E-01 -4.993384E-01 1.823903E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.378699E+05 P = 5.893585E+04 1.889238E+05 -1.319714E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.194078E+05 P = -4.804417E+04 -1.937944E+05 9.096846E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.249769E+01 P = -8.422210E+00 2.221674E+00 -8.962304E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.270975E+04 P = -1.088326E+04 4.868384E+03 4.101191E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805407E+04 1.937938E+05 -9.095926E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.654943E+04 -2.196648E+05 6.246431E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191382E+01 P = -9.115983E+00 -5.764865E-01 -7.648893E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271014E+04 P = 1.850448E+04 2.587164E+04 2.850260E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.43238E-11 sqme_ref* => 5.35570E-11 event_index* => 3 event_weight* => 2.62618E-11 event_weight_ref* => 4.09774E-11 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.3786993E+05; 5.8935849E+04, 1.8892384E+05,-1.3197141E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.1940782E+05;-4.8044166E+04,-1.9379445E+05, 9.0968461E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.2497694E+01;-8.4222096E+00, 2.2216738E+00,-8.9623041E+00| 0.0000000E+00| 5) - 6 prt(o:21| 4.2709754E+04;-1.0883261E+04, 4.8683835E+03, 4.1011908E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.249769XE+01;-8.422209XE+00, 2.221673XE+00,-8.962304XE+00| 0.000000XE+00| 5) + 6 prt(o:21| 4.270975XE+04;-1.088326XE+04, 4.868383XE+03, 4.101190XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #3 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 5.35570E-11 Squared matrix el. (prc) = 1.92332E-11 Event weight (ref) = 4.09774E-11 Event weight (prc) = 1.47156E-11 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 658726814.0, 695277609.0, 1316830081.0, 2131992430.0, 749504030.0, 880099028.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499928E+05 P = 5.475198E+04 2.208103E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.499951E+05 P = -5.474321E+04 -2.208111E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210258E+01 P = -8.773290E+00 8.057940E-01 -8.297738E+00 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1100463693.0, 3654384047.0, 647619641.0, 459938003.0, 1733458346.0, 3954010958.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805407E+04 1.937938E+05 -9.095926E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.654943E+04 -2.196648E+05 6.246431E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191382E+01 P = -9.115983E+00 -5.764865E-01 -7.648893E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271014E+04 P = 1.850448E+04 2.587164E+04 2.850260E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.923316838E-11 +sqme_rad = 1.92331683XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499928E+05 P = 5.475198E+04 2.208103E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499951E+05 P = -5.474321E+04 -2.208111E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210258E+01 P = -8.773290E+00 8.057940E-01 -8.297738E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499931E+05 P = 5.475092E+04 2.208104E+05 -1.036419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499948E+05 P = -5.474427E+04 -2.208110E+05 1.036482E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 1.003499E+01 P = -5.807928E+00 1.109576E+00 -8.107885E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 2.067652E+00 P = -8.361955E-01 -4.993384E-01 1.823903E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.378699E+05 P = 5.893585E+04 1.889238E+05 -1.319714E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.194078E+05 P = -4.804417E+04 -1.937944E+05 9.096846E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.249769E+01 P = -8.422210E+00 2.221674E+00 -8.962304E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.270975E+04 P = -1.088326E+04 4.868384E+03 4.101191E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805407E+04 1.937938E+05 -9.095926E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.654943E+04 -2.196648E+05 6.246431E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191382E+01 P = -9.115983E+00 -5.764865E-01 -7.648893E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271014E+04 P = 1.850448E+04 2.587164E+04 2.850260E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.92332E-11 sqme_ref* => 5.35570E-11 event_index* => 3 event_weight* => 1.47156E-11 event_weight_ref* => 4.09774E-11 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.1940558E+05; 4.8054072E+04, 1.9379378E+05,-9.0959260E+04| 0.0000000E+00| 3) 4 prt(o:2| 2.3787237E+05;-6.6549434E+04,-2.1966485E+05, 6.2464312E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.1913818E+01;-9.1159833E+00,-5.7648647E-01,-7.6488930E+00| 0.0000000E+00| 5) - 6 prt(o:21| 4.2710135E+04; 1.8504478E+04, 2.5871643E+04, 2.8502597E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.191381XE+01;-9.115983XE+00,-5.764864XE-01,-7.648893XE+00| 0.000000XE+00| 5) + 6 prt(o:21| 4.271013XE+04; 1.850447XE+04, 2.587164XE+04, 2.850259XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #4 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.11517E-10 Squared matrix el. (prc) = -4.20083E-09 Event weight (ref) = 2.67271E-07 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 852933358.0, 3802412940.0, 3514872455.0, 1024477926.0, 3849273974.0, 775318609.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.376849E+05 P = -9.735941E+04 -1.760922E+05 -1.265180E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.496755E+05 P = 1.059920E+05 1.834884E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263960E+04 P = -8.632579E+03 -7.396266E+03 -5.525692E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 598672993.0, 229519251.0, 2192350721.0, 2167080660.0, 1984333633.0, 1125498793.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.783117E+04 -1.249743E+05 -8.973205E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.185949E+04 3.511553E+04 1.694878E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158712E+03 P = -7.046516E+03 -4.650547E+03 -3.549792E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673718E+04 9.450927E+04 -7.620601E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.057478561E-12 +sqme_rad = 2.05747856XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.376849E+05 P = -9.735941E+04 -1.760922E+05 -1.265180E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.496755E+05 P = 1.059920E+05 1.834884E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263960E+04 P = -8.632579E+03 -7.396266E+03 -5.525692E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.402098E+05 P = -9.918120E+04 -1.776531E+05 -1.276841E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.470398E+05 P = 1.040984E+05 1.818661E+05 1.308317E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 5.196868E+03 P = -1.975113E+03 -3.053897E+03 3.712152E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 7.553465E+03 P = -2.942136E+03 -1.159129E+03 -6.859671E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.595905E+05 P = -4.905718E+04 -1.427668E+05 5.177036E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.811710E+05 P = 7.792629E+04 1.327265E+05 9.557249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.719719E+04 P = -1.057617E+04 -1.091161E+04 -8.051381E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.420413E+05 P = -1.829293E+04 2.095187E+04 -1.392915E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.783117E+04 -1.249743E+05 -8.973205E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.185949E+04 3.511553E+04 1.694878E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158712E+03 P = -7.046516E+03 -4.650547E+03 -3.549792E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673718E+04 9.450927E+04 -7.620601E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => -4.20083E-09 sqme_ref* => 2.11517E-10 event_index* => 4 event_weight* => 0.00000E+00 event_weight_ref* => 2.67271E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.3768491E+05;-9.7359407E+04,-1.7609218E+05,-1.2651802E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4967549E+05; 1.0599199E+05, 1.8348844E+05, 1.3204371E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2639598E+04;-8.6325789E+03,-7.3962655E+03,-5.5256921E+03| 0.0000000E+00| 5) + 5 prt(o:21| 1.263959XE+04;-8.632578XE+03,-7.396265XE+03,-5.525692XE+03| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #4 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.11517E-10 Squared matrix el. (prc) = 2.07645E-10 Event weight (ref) = 2.67271E-07 Event weight (prc) = 2.62379E-07 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 852933358.0, 3802412940.0, 3514872455.0, 1024477926.0, 3849273974.0, 775318609.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.376849E+05 P = -9.735941E+04 -1.760922E+05 -1.265180E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.496755E+05 P = 1.059920E+05 1.834884E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263960E+04 P = -8.632579E+03 -7.396266E+03 -5.525692E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 598672993.0, 229519251.0, 2192350721.0, 2167080660.0, 1984333633.0, 1125498793.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.783117E+04 -1.249743E+05 -8.973205E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.185949E+04 3.511553E+04 1.694878E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158712E+03 P = -7.046516E+03 -4.650547E+03 -3.549792E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673718E+04 9.450927E+04 -7.620601E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.057478561E-12 +sqme_rad = 2.05747856XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.376849E+05 P = -9.735941E+04 -1.760922E+05 -1.265180E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.496755E+05 P = 1.059920E+05 1.834884E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263960E+04 P = -8.632579E+03 -7.396266E+03 -5.525692E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.402098E+05 P = -9.918120E+04 -1.776531E+05 -1.276841E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.470398E+05 P = 1.040984E+05 1.818661E+05 1.308317E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 5.196868E+03 P = -1.975113E+03 -3.053897E+03 3.712152E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 7.553465E+03 P = -2.942136E+03 -1.159129E+03 -6.859671E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.595905E+05 P = -4.905718E+04 -1.427668E+05 5.177036E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.811710E+05 P = 7.792629E+04 1.327265E+05 9.557249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.719719E+04 P = -1.057617E+04 -1.091161E+04 -8.051381E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.420413E+05 P = -1.829293E+04 2.095187E+04 -1.392915E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.783117E+04 -1.249743E+05 -8.973205E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.185949E+04 3.511553E+04 1.694878E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158712E+03 P = -7.046516E+03 -4.650547E+03 -3.549792E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673718E+04 9.450927E+04 -7.620601E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.07645E-10 sqme_ref* => 2.11517E-10 event_index* => 4 event_weight* => 2.62379E-07 event_weight_ref* => 2.67271E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-3| 2.4020982E+05;-9.9181199E+04,-1.7765306E+05,-1.2768414E+05| 0.0000000E+00| 3) 4 prt(o:3| 2.4703984E+05; 1.0409845E+05, 1.8186609E+05, 1.3083166E+05| 0.0000000E+00| 4) - 5 prt(o:21| 5.1968680E+03;-1.9751131E+03,-3.0538975E+03, 3.7121524E+03| 0.0000000E+00| 5) - 6 prt(o:21| 7.5534651E+03;-2.9421361E+03,-1.1591287E+03,-6.8596713E+03| 0.0000000E+00| 6) + 5 prt(o:21| 5.196868XE+03;-1.975113XE+03,-3.053897XE+03, 3.712152XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 7.553465XE+03;-2.942136XE+03,-1.159128XE+03,-6.859671XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #4 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.11517E-10 Squared matrix el. (prc) = 1.81416E-12 Event weight (ref) = 2.67271E-07 Event weight (prc) = 2.29236E-09 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 852933358.0, 3802412940.0, 3514872455.0, 1024477926.0, 3849273974.0, 775318609.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.376849E+05 P = -9.735941E+04 -1.760922E+05 -1.265180E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.496755E+05 P = 1.059920E+05 1.834884E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263960E+04 P = -8.632579E+03 -7.396266E+03 -5.525692E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 598672993.0, 229519251.0, 2192350721.0, 2167080660.0, 1984333633.0, 1125498793.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.783117E+04 -1.249743E+05 -8.973205E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.185949E+04 3.511553E+04 1.694878E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158712E+03 P = -7.046516E+03 -4.650547E+03 -3.549792E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673718E+04 9.450927E+04 -7.620601E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.057478561E-12 +sqme_rad = 2.05747856XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.376849E+05 P = -9.735941E+04 -1.760922E+05 -1.265180E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.496755E+05 P = 1.059920E+05 1.834884E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263960E+04 P = -8.632579E+03 -7.396266E+03 -5.525692E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.402098E+05 P = -9.918120E+04 -1.776531E+05 -1.276841E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.470398E+05 P = 1.040984E+05 1.818661E+05 1.308317E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 5.196868E+03 P = -1.975113E+03 -3.053897E+03 3.712152E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 7.553465E+03 P = -2.942136E+03 -1.159129E+03 -6.859671E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.595905E+05 P = -4.905718E+04 -1.427668E+05 5.177036E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.811710E+05 P = 7.792629E+04 1.327265E+05 9.557249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.719719E+04 P = -1.057617E+04 -1.091161E+04 -8.051381E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.420413E+05 P = -1.829293E+04 2.095187E+04 -1.392915E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.783117E+04 -1.249743E+05 -8.973205E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.185949E+04 3.511553E+04 1.694878E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158712E+03 P = -7.046516E+03 -4.650547E+03 -3.549792E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673718E+04 9.450927E+04 -7.620601E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.81416E-12 sqme_ref* => 2.11517E-10 event_index* => 4 event_weight* => 2.29236E-09 event_weight_ref* => 2.67271E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.5959052E+05;-4.9057181E+04,-1.4276679E+05, 5.1770364E+04| 0.0000000E+00| 3) 4 prt(o:2| 1.8117101E+05; 7.7926286E+04, 1.3272652E+05, 9.5572486E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.7197189E+04;-1.0576172E+04,-1.0911607E+04,-8.0513808E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.4204128E+05;-1.8292933E+04, 2.0951870E+04,-1.3929147E+05| 0.0000000E+00| 6) + 5 prt(o:21| 1.719718XE+04;-1.057617XE+04,-1.091160XE+04,-8.051380XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.420412XE+05;-1.829293XE+04, 2.095187XE+04,-1.392914XE+05| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #4 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.11517E-10 Squared matrix el. (prc) = 2.05748E-12 Event weight (ref) = 2.67271E-07 Event weight (prc) = 2.59981E-09 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 852933358.0, 3802412940.0, 3514872455.0, 1024477926.0, 3849273974.0, 775318609.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.376849E+05 P = -9.735941E+04 -1.760922E+05 -1.265180E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.496755E+05 P = 1.059920E+05 1.834884E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263960E+04 P = -8.632579E+03 -7.396266E+03 -5.525692E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 598672993.0, 229519251.0, 2192350721.0, 2167080660.0, 1984333633.0, 1125498793.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.783117E+04 -1.249743E+05 -8.973205E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.185949E+04 3.511553E+04 1.694878E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158712E+03 P = -7.046516E+03 -4.650547E+03 -3.549792E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673718E+04 9.450927E+04 -7.620601E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.057478561E-12 +sqme_rad = 2.05747856XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.376849E+05 P = -9.735941E+04 -1.760922E+05 -1.265180E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.496755E+05 P = 1.059920E+05 1.834884E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263960E+04 P = -8.632579E+03 -7.396266E+03 -5.525692E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.402098E+05 P = -9.918120E+04 -1.776531E+05 -1.276841E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.470398E+05 P = 1.040984E+05 1.818661E+05 1.308317E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 5.196868E+03 P = -1.975113E+03 -3.053897E+03 3.712152E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 7.553465E+03 P = -2.942136E+03 -1.159129E+03 -6.859671E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.595905E+05 P = -4.905718E+04 -1.427668E+05 5.177036E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.811710E+05 P = 7.792629E+04 1.327265E+05 9.557249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.719719E+04 P = -1.057617E+04 -1.091161E+04 -8.051381E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.420413E+05 P = -1.829293E+04 2.095187E+04 -1.392915E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.783117E+04 -1.249743E+05 -8.973205E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.185949E+04 3.511553E+04 1.694878E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158712E+03 P = -7.046516E+03 -4.650547E+03 -3.549792E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673718E+04 9.450927E+04 -7.620601E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.05748E-12 sqme_ref* => 2.11517E-10 event_index* => 4 event_weight* => 2.59981E-09 event_weight_ref* => 2.67271E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-3| 1.6814123E+05;-6.7831172E+04,-1.2497426E+05,-8.9732051E+04| 0.0000000E+00| 3) 4 prt(o:3| 1.7349317E+05;-1.1859494E+04, 3.5115532E+04, 1.6948785E+05| 0.0000000E+00| 4) - 5 prt(o:21| 9.1587121E+03;-7.0465164E+03,-4.6505472E+03,-3.5497920E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.4920689E+05; 8.6737182E+04, 9.4509270E+04,-7.6206006E+04| 0.0000000E+00| 6) + 5 prt(o:21| 9.158712XE+03;-7.046516XE+03,-4.650547XE+03,-3.549792XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.492068XE+05; 8.673718XE+04, 9.450927XE+04,-7.620600XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #5 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 9.37950E-07 Squared matrix el. (prc) = 7.86867E-07 Event weight (ref) = 6.19706E-04 Event weight (prc) = 5.19885E-04 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 1 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1095625977.0, 443063532.0, 2957163220.0, 222499157.0, 3835620558.0, 2328100909.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012367E+04 1.513506E+05 -1.966194E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951646E+04 -1.505960E+05 1.958701E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224531E+03 P = 6.072096E+02 -7.545382E+02 7.492960E+02 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1106982763.0, 4232153153.0, 2882700880.0, 3746330306.0, 161521528.0, 2991739543.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325594E+04 1.163107E+05 -1.510454E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237789E+05 -4.406944E+04 3.166392E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565421E+03 P = 6.505595E+02 -9.757142E+02 1.036965E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712317E+05 P = -1.011735E+05 -7.126557E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848894375E-12 +sqme_rad = 3.84889437XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012367E+04 1.513506E+05 -1.966194E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951646E+04 -1.505960E+05 1.958701E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224531E+03 P = 6.072096E+02 -7.545382E+02 7.492960E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.497695E+05 P = -3.002724E+04 1.512308E+05 -1.965004E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.490052E+05 P = 2.961252E+04 -1.507154E+05 1.959886E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.826693E+02 P = 3.602519E+02 1.245420E+02 -3.381823E+01 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.426635E+02 P = 5.446820E+01 -6.398866E+02 5.455824E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.362137E+05 P = -1.144985E+05 -7.433513E+03 -7.340982E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.908174E+05 P = 2.252497E+04 -1.154686E+05 1.502361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.672550E+02 P = 5.723545E+02 -5.794158E+02 5.217948E+02 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.720017E+05 P = 9.140115E+04 1.234816E+05 -7.734808E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325594E+04 1.163107E+05 -1.510454E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237789E+05 -4.406944E+04 3.166392E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565421E+03 P = 6.505595E+02 -9.757142E+02 1.036965E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712317E+05 P = -1.011735E+05 -7.126557E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 7.86867E-07 sqme_ref* => 9.37950E-07 event_index* => 5 event_weight* => 5.19885E-04 event_weight_ref* => 6.19706E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4994724E+05;-3.0123669E+04, 1.5135059E+05,-1.9661940E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4882823E+05; 2.9516460E+04,-1.5059605E+05, 1.9587010E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2245309E+03; 6.0720956E+02,-7.5453818E+02, 7.4929605E+02| 0.0000000E+00| 5) + 5 prt(o:21| 1.224530XE+03; 6.072095XE+02,-7.545381XE+02, 7.492960XE+02| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #5 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 9.37950E-07 Squared matrix el. (prc) = 1.51076E-07 Event weight (ref) = 6.19706E-04 Event weight (prc) = 9.98166E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 1 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1095625977.0, 443063532.0, 2957163220.0, 222499157.0, 3835620558.0, 2328100909.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012367E+04 1.513506E+05 -1.966194E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951646E+04 -1.505960E+05 1.958701E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224531E+03 P = 6.072096E+02 -7.545382E+02 7.492960E+02 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1106982763.0, 4232153153.0, 2882700880.0, 3746330306.0, 161521528.0, 2991739543.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325594E+04 1.163107E+05 -1.510454E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237789E+05 -4.406944E+04 3.166392E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565421E+03 P = 6.505595E+02 -9.757142E+02 1.036965E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712317E+05 P = -1.011735E+05 -7.126557E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848894375E-12 +sqme_rad = 3.84889437XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012367E+04 1.513506E+05 -1.966194E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951646E+04 -1.505960E+05 1.958701E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224531E+03 P = 6.072096E+02 -7.545382E+02 7.492960E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.497695E+05 P = -3.002724E+04 1.512308E+05 -1.965004E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.490052E+05 P = 2.961252E+04 -1.507154E+05 1.959886E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.826693E+02 P = 3.602519E+02 1.245420E+02 -3.381823E+01 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.426635E+02 P = 5.446820E+01 -6.398866E+02 5.455824E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.362137E+05 P = -1.144985E+05 -7.433513E+03 -7.340982E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.908174E+05 P = 2.252497E+04 -1.154686E+05 1.502361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.672550E+02 P = 5.723545E+02 -5.794158E+02 5.217948E+02 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.720017E+05 P = 9.140115E+04 1.234816E+05 -7.734808E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325594E+04 1.163107E+05 -1.510454E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237789E+05 -4.406944E+04 3.166392E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565421E+03 P = 6.505595E+02 -9.757142E+02 1.036965E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712317E+05 P = -1.011735E+05 -7.126557E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.51076E-07 sqme_ref* => 9.37950E-07 event_index* => 5 event_weight* => 9.98166E-05 event_weight_ref* => 6.19706E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-3| 2.4976947E+05;-3.0027243E+04, 1.5123076E+05,-1.9650041E+05| 0.0000000E+00| 3) 4 prt(o:3| 2.4900520E+05; 2.9612523E+04,-1.5071542E+05, 1.9598864E+05| 0.0000000E+00| 4) - 5 prt(o:21| 3.8266933E+02; 3.6025189E+02, 1.2454202E+02,-3.3818229E+01| 0.0000000E+00| 5) - 6 prt(o:21| 8.4266352E+02; 5.4468196E+01,-6.3988657E+02, 5.4558244E+02| 0.0000000E+00| 6) + 5 prt(o:21| 3.826693XE+02; 3.602518XE+02, 1.245420XE+02,-3.381822XE+01| 0.000000XE+00| 5) + 6 prt(o:21| 8.426635XE+02; 5.446819XE+01,-6.398865XE+02, 5.455824XE+02| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #5 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 9.37950E-07 Squared matrix el. (prc) = 2.69142E-12 Event weight (ref) = 6.19706E-04 Event weight (prc) = 1.77823E-09 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 1 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1095625977.0, 443063532.0, 2957163220.0, 222499157.0, 3835620558.0, 2328100909.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012367E+04 1.513506E+05 -1.966194E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951646E+04 -1.505960E+05 1.958701E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224531E+03 P = 6.072096E+02 -7.545382E+02 7.492960E+02 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1106982763.0, 4232153153.0, 2882700880.0, 3746330306.0, 161521528.0, 2991739543.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325594E+04 1.163107E+05 -1.510454E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237789E+05 -4.406944E+04 3.166392E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565421E+03 P = 6.505595E+02 -9.757142E+02 1.036965E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712317E+05 P = -1.011735E+05 -7.126557E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848894375E-12 +sqme_rad = 3.84889437XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012367E+04 1.513506E+05 -1.966194E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951646E+04 -1.505960E+05 1.958701E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224531E+03 P = 6.072096E+02 -7.545382E+02 7.492960E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.497695E+05 P = -3.002724E+04 1.512308E+05 -1.965004E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.490052E+05 P = 2.961252E+04 -1.507154E+05 1.959886E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.826693E+02 P = 3.602519E+02 1.245420E+02 -3.381823E+01 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.426635E+02 P = 5.446820E+01 -6.398866E+02 5.455824E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.362137E+05 P = -1.144985E+05 -7.433513E+03 -7.340982E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.908174E+05 P = 2.252497E+04 -1.154686E+05 1.502361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.672550E+02 P = 5.723545E+02 -5.794158E+02 5.217948E+02 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.720017E+05 P = 9.140115E+04 1.234816E+05 -7.734808E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325594E+04 1.163107E+05 -1.510454E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237789E+05 -4.406944E+04 3.166392E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565421E+03 P = 6.505595E+02 -9.757142E+02 1.036965E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712317E+05 P = -1.011735E+05 -7.126557E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.69142E-12 sqme_ref* => 9.37950E-07 event_index* => 5 event_weight* => 1.77823E-09 event_weight_ref* => 6.19706E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 1.3621365E+05;-1.1449847E+05,-7.4335128E+03,-7.3409822E+04| 0.0000000E+00| 3) 4 prt(o:1| 1.9081737E+05; 2.2524966E+04,-1.1546863E+05, 1.5023611E+05| 0.0000000E+00| 4) - 5 prt(o:21| 9.6725498E+02; 5.7235454E+02,-5.7941582E+02, 5.2179477E+02| 0.0000000E+00| 5) - 6 prt(o:21| 1.7200172E+05; 9.1401152E+04, 1.2348156E+05,-7.7348083E+04| 0.0000000E+00| 6) + 5 prt(o:21| 9.672549XE+02; 5.723545XE+02,-5.794158XE+02, 5.217947XE+02| 0.000000XE+00| 5) + 6 prt(o:21| 1.720017XE+05; 9.140115XE+04, 1.234815XE+05,-7.734808XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #5 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 9.37950E-07 Squared matrix el. (prc) = 3.84889E-12 Event weight (ref) = 6.19706E-04 Event weight (prc) = 2.54297E-09 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 1 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1095625977.0, 443063532.0, 2957163220.0, 222499157.0, 3835620558.0, 2328100909.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012367E+04 1.513506E+05 -1.966194E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951646E+04 -1.505960E+05 1.958701E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224531E+03 P = 6.072096E+02 -7.545382E+02 7.492960E+02 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1106982763.0, 4232153153.0, 2882700880.0, 3746330306.0, 161521528.0, 2991739543.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325594E+04 1.163107E+05 -1.510454E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237789E+05 -4.406944E+04 3.166392E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565421E+03 P = 6.505595E+02 -9.757142E+02 1.036965E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712317E+05 P = -1.011735E+05 -7.126557E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848894375E-12 +sqme_rad = 3.84889437XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012367E+04 1.513506E+05 -1.966194E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951646E+04 -1.505960E+05 1.958701E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224531E+03 P = 6.072096E+02 -7.545382E+02 7.492960E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.497695E+05 P = -3.002724E+04 1.512308E+05 -1.965004E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.490052E+05 P = 2.961252E+04 -1.507154E+05 1.959886E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.826693E+02 P = 3.602519E+02 1.245420E+02 -3.381823E+01 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.426635E+02 P = 5.446820E+01 -6.398866E+02 5.455824E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.362137E+05 P = -1.144985E+05 -7.433513E+03 -7.340982E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.908174E+05 P = 2.252497E+04 -1.154686E+05 1.502361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.672550E+02 P = 5.723545E+02 -5.794158E+02 5.217948E+02 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.720017E+05 P = 9.140115E+04 1.234816E+05 -7.734808E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325594E+04 1.163107E+05 -1.510454E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237789E+05 -4.406944E+04 3.166392E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565421E+03 P = 6.505595E+02 -9.757142E+02 1.036965E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712317E+05 P = -1.011735E+05 -7.126557E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.84889E-12 sqme_ref* => 9.37950E-07 event_index* => 5 event_weight* => 2.54297E-09 event_weight_ref* => 6.19706E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.9205140E+05;-2.3255941E+04, 1.1631072E+05,-1.5104542E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.3515151E+05; 1.2377888E+05,-4.4069441E+04, 3.1663917E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.5654207E+03; 6.5055954E+02,-9.7571425E+02, 1.0369648E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.7123167E+05;-1.0117349E+05,-7.1265568E+04, 1.1834453E+05| 0.0000000E+00| 6) + 5 prt(o:21| 1.565420XE+03; 6.505595XE+02,-9.757142XE+02, 1.036964XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.712316XE+05;-1.011734XE+05,-7.126556XE+04, 1.183445XE+05| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #6 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 0.00000E+00 Squared matrix el. (prc) = 0.00000E+00 Event weight (ref) = 0.00000E+00 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2643453732.0, 343801519.0, 3374377404.0, 2585822891.0, 2834629654.0, 677007669.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.705136E+03 5.495284E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.751606E+03 -3.868985E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.647034E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2714720639.0, 1946415819.0, 2496115977.0, 2267707328.0, 4192754391.0, 3326698294.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.704826E+03 5.494600E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201881E+04 P = 8.515933E+02 -1.424707E+04 7.059040E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.637791E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.602797E+03 -2.443390E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848894375E-12 +sqme_rad = 3.84889437XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.705136E+03 5.495284E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.751606E+03 -3.868985E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.647034E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499853E+05 P = 1.705144E+03 5.494997E+04 -2.438652E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754291E+05 P = -1.751600E+03 -3.869187E+04 1.711001E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 3.061427E+04 P = 6.525787E+02 -5.947960E+03 3.002382E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 4.397136E+04 P = -6.061224E+02 -1.031014E+04 4.274125E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.026503E+05 P = -1.354957E+03 2.503841E+04 -9.954059E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.753888E+05 P = -1.751395E+03 -3.868303E+04 1.710608E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.456851E+04 P = 4.656031E+01 -1.626009E+04 7.277410E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.473923E+05 P = 3.059791E+03 2.990472E+04 -1.442943E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.704826E+03 5.494600E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201881E+04 P = 8.515933E+02 -1.424707E+04 7.059040E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.637791E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.602797E+03 -2.443390E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 0.00000E+00 sqme_ref* => 0.00000E+00 event_index* => 6 event_weight* => 0.00000E+00 event_weight_ref* => 0.00000E+00 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4999844E+05; 1.7051358E+03, 5.4952843E+04,-2.4387804E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.7541986E+05;-1.7516062E+03,-3.8689852E+04, 1.7109107E+05| 0.0000000E+00| 4) - 5 prt(o:21| 7.4581696E+04; 4.6470340E+01,-1.6262990E+04, 7.2786966E+04| 0.0000000E+00| 5) + 5 prt(o:21| 7.458169XE+04; 4.647034XE+01,-1.626299XE+04, 7.278696XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #6 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 0.00000E+00 Squared matrix el. (prc) = 0.00000E+00 Event weight (ref) = 0.00000E+00 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2643453732.0, 343801519.0, 3374377404.0, 2585822891.0, 2834629654.0, 677007669.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.705136E+03 5.495284E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.751606E+03 -3.868985E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.647034E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2714720639.0, 1946415819.0, 2496115977.0, 2267707328.0, 4192754391.0, 3326698294.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.704826E+03 5.494600E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201881E+04 P = 8.515933E+02 -1.424707E+04 7.059040E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.637791E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.602797E+03 -2.443390E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848894375E-12 +sqme_rad = 3.84889437XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.705136E+03 5.495284E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.751606E+03 -3.868985E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.647034E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499853E+05 P = 1.705144E+03 5.494997E+04 -2.438652E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754291E+05 P = -1.751600E+03 -3.869187E+04 1.711001E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 3.061427E+04 P = 6.525787E+02 -5.947960E+03 3.002382E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 4.397136E+04 P = -6.061224E+02 -1.031014E+04 4.274125E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.026503E+05 P = -1.354957E+03 2.503841E+04 -9.954059E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.753888E+05 P = -1.751395E+03 -3.868303E+04 1.710608E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.456851E+04 P = 4.656031E+01 -1.626009E+04 7.277410E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.473923E+05 P = 3.059791E+03 2.990472E+04 -1.442943E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.704826E+03 5.494600E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201881E+04 P = 8.515933E+02 -1.424707E+04 7.059040E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.637791E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.602797E+03 -2.443390E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 0.00000E+00 sqme_ref* => 0.00000E+00 event_index* => 6 event_weight* => 0.00000E+00 event_weight_ref* => 0.00000E+00 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4998525E+05; 1.7051441E+03, 5.4949967E+04,-2.4386517E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.7542912E+05;-1.7516004E+03,-3.8691871E+04, 1.7110011E+05| 0.0000000E+00| 4) 5 prt(o:-2| 3.0614272E+04; 6.5257875E+02,-5.9479598E+03, 3.0023816E+04| 0.0000000E+00| 5) 6 prt(o:2| 4.3971359E+04;-6.0612239E+02,-1.0310136E+04, 4.2741246E+04| 0.0000000E+00| 6) ======================================================================== ======================================================================== Event #6 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 0.00000E+00 Squared matrix el. (prc) = 0.00000E+00 Event weight (ref) = 0.00000E+00 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2643453732.0, 343801519.0, 3374377404.0, 2585822891.0, 2834629654.0, 677007669.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.705136E+03 5.495284E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.751606E+03 -3.868985E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.647034E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2714720639.0, 1946415819.0, 2496115977.0, 2267707328.0, 4192754391.0, 3326698294.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.704826E+03 5.494600E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201881E+04 P = 8.515933E+02 -1.424707E+04 7.059040E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.637791E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.602797E+03 -2.443390E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848894375E-12 +sqme_rad = 3.84889437XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.705136E+03 5.495284E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.751606E+03 -3.868985E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.647034E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499853E+05 P = 1.705144E+03 5.494997E+04 -2.438652E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754291E+05 P = -1.751600E+03 -3.869187E+04 1.711001E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 3.061427E+04 P = 6.525787E+02 -5.947960E+03 3.002382E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 4.397136E+04 P = -6.061224E+02 -1.031014E+04 4.274125E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.026503E+05 P = -1.354957E+03 2.503841E+04 -9.954059E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.753888E+05 P = -1.751395E+03 -3.868303E+04 1.710608E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.456851E+04 P = 4.656031E+01 -1.626009E+04 7.277410E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.473923E+05 P = 3.059791E+03 2.990472E+04 -1.442943E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.704826E+03 5.494600E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201881E+04 P = 8.515933E+02 -1.424707E+04 7.059040E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.637791E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.602797E+03 -2.443390E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 0.00000E+00 sqme_ref* => 0.00000E+00 event_index* => 6 event_weight* => 0.00000E+00 event_weight_ref* => 0.00000E+00 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.0265031E+05;-1.3549569E+03, 2.5038406E+04,-9.9540591E+04| 0.0000000E+00| 3) 4 prt(o:2| 1.7538884E+05;-1.7513946E+03,-3.8683032E+04, 1.7106081E+05| 0.0000000E+00| 4) 5 prt(o:-2| 7.4568505E+04; 4.6560312E+01,-1.6260091E+04, 7.2774098E+04| 0.0000000E+00| 5) 6 prt(o:2| 1.4739234E+05; 3.0597912E+03, 2.9904717E+04,-1.4429431E+05| 0.0000000E+00| 6) ======================================================================== ======================================================================== Event #6 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 0.00000E+00 Squared matrix el. (prc) = 0.00000E+00 Event weight (ref) = 0.00000E+00 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2643453732.0, 343801519.0, 3374377404.0, 2585822891.0, 2834629654.0, 677007669.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.705136E+03 5.495284E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.751606E+03 -3.868985E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.647034E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2714720639.0, 1946415819.0, 2496115977.0, 2267707328.0, 4192754391.0, 3326698294.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.704826E+03 5.494600E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201881E+04 P = 8.515933E+02 -1.424707E+04 7.059040E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.637791E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.602797E+03 -2.443390E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848894375E-12 +sqme_rad = 3.84889437XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.705136E+03 5.495284E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.751606E+03 -3.868985E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.647034E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499853E+05 P = 1.705144E+03 5.494997E+04 -2.438652E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754291E+05 P = -1.751600E+03 -3.869187E+04 1.711001E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 3.061427E+04 P = 6.525787E+02 -5.947960E+03 3.002382E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 4.397136E+04 P = -6.061224E+02 -1.031014E+04 4.274125E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.026503E+05 P = -1.354957E+03 2.503841E+04 -9.954059E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.753888E+05 P = -1.751395E+03 -3.868303E+04 1.710608E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.456851E+04 P = 4.656031E+01 -1.626009E+04 7.277410E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.473923E+05 P = 3.059791E+03 2.990472E+04 -1.442943E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.704826E+03 5.494600E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201881E+04 P = 8.515933E+02 -1.424707E+04 7.059040E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.637791E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.602797E+03 -2.443390E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 0.00000E+00 sqme_ref* => 0.00000E+00 event_index* => 6 event_weight* => 0.00000E+00 event_weight_ref* => 0.00000E+00 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4996742E+05; 1.7048261E+03, 5.4946000E+04,-2.4384778E+05| 0.0000000E+00| 3) 4 prt(o:2| 7.2018806E+04; 8.5159327E+02,-1.4247070E+04, 7.0590398E+04| 0.0000000E+00| 4) 5 prt(o:-2| 7.4590952E+04; 4.6377911E+01,-1.6265032E+04, 7.2795994E+04| 0.0000000E+00| 5) 6 prt(o:2| 1.0342282E+05;-2.6027972E+03,-2.4433899E+04, 1.0046139E+05| 0.0000000E+00| 6) ======================================================================== ======================================================================== Event #7 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 8.55502E-11 Squared matrix el. (prc) = 3.55892E-11 Event weight (ref) = 7.63620E-07 Event weight (prc) = 3.17669E-07 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2042523454.0, 1790911384.0, 3715479539.0, 3582083863.0, 2240445629.0, 3470253870.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.195207E+05 P = 1.239520E+04 7.088145E+04 -2.073922E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.402876E+05 P = -4.887334E+04 -7.109917E+04 2.242642E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019162E+04 P = 3.647814E+04 2.177158E+02 -1.687201E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3203562530.0, 370100846.0, 1647107524.0, 1466280485.0, 4189984473.0, 360074395.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.133485E+03 4.829088E+04 -1.361360E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577453E+04 3.340275E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369713E+04 P = 3.332597E+04 -4.367942E+03 -2.407721E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059670E+05 -7.732569E+04 -2.952267E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.501741013E-12 +sqme_rad = 1.50174101XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.195207E+05 P = 1.239520E+04 7.088145E+04 -2.073922E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.402876E+05 P = -4.887334E+04 -7.109917E+04 2.242642E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019162E+04 P = 3.647814E+04 2.177158E+02 -1.687201E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.244498E+05 P = 2.194794E+04 7.093846E+04 -2.118106E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.339690E+05 P = -3.866894E+04 -7.103826E+04 2.195445E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.909057E+04 P = 1.211131E+04 6.048999E+03 1.346015E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.249063E+04 P = 4.609689E+03 -5.949202E+03 -2.119402E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.604817E+05 P = -1.426073E+04 1.471366E+05 -6.246454E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.668286E+05 P = -4.465708E+04 -4.698866E+04 1.537192E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.984915E+04 P = 3.741064E+04 5.550170E+03 -3.247426E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.228405E+05 P = 2.150718E+04 -1.056981E+05 -5.878044E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.133485E+03 4.829088E+04 -1.361360E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577453E+04 3.340275E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369713E+04 P = 3.332597E+04 -4.367942E+03 -2.407721E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059670E+05 -7.732569E+04 -2.952267E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.55892E-11 sqme_ref* => 8.55502E-11 event_index* => 7 event_weight* => 3.17669E-07 event_weight_ref* => 7.63620E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.1952075E+05; 1.2395198E+04, 7.0881450E+04,-2.0739223E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4028763E+05;-4.8873335E+04,-7.1099166E+04, 2.2426424E+05| 0.0000000E+00| 4) - 5 prt(o:21| 4.0191625E+04; 3.6478137E+04, 2.1771584E+02,-1.6872013E+04| 0.0000000E+00| 5) + 5 prt(o:21| 4.019162XE+04; 3.647813XE+04, 2.177158XE+02,-1.687201XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #7 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 8.55502E-11 Squared matrix el. (prc) = 4.70452E-11 Event weight (ref) = 7.63620E-07 Event weight (prc) = 4.19925E-07 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2042523454.0, 1790911384.0, 3715479539.0, 3582083863.0, 2240445629.0, 3470253870.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.195207E+05 P = 1.239520E+04 7.088145E+04 -2.073922E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.402876E+05 P = -4.887334E+04 -7.109917E+04 2.242642E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019162E+04 P = 3.647814E+04 2.177158E+02 -1.687201E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3203562530.0, 370100846.0, 1647107524.0, 1466280485.0, 4189984473.0, 360074395.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.133485E+03 4.829088E+04 -1.361360E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577453E+04 3.340275E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369713E+04 P = 3.332597E+04 -4.367942E+03 -2.407721E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059670E+05 -7.732569E+04 -2.952267E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.501741013E-12 +sqme_rad = 1.50174101XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.195207E+05 P = 1.239520E+04 7.088145E+04 -2.073922E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.402876E+05 P = -4.887334E+04 -7.109917E+04 2.242642E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019162E+04 P = 3.647814E+04 2.177158E+02 -1.687201E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.244498E+05 P = 2.194794E+04 7.093846E+04 -2.118106E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.339690E+05 P = -3.866894E+04 -7.103826E+04 2.195445E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.909057E+04 P = 1.211131E+04 6.048999E+03 1.346015E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.249063E+04 P = 4.609689E+03 -5.949202E+03 -2.119402E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.604817E+05 P = -1.426073E+04 1.471366E+05 -6.246454E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.668286E+05 P = -4.465708E+04 -4.698866E+04 1.537192E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.984915E+04 P = 3.741064E+04 5.550170E+03 -3.247426E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.228405E+05 P = 2.150718E+04 -1.056981E+05 -5.878044E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.133485E+03 4.829088E+04 -1.361360E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577453E+04 3.340275E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369713E+04 P = 3.332597E+04 -4.367942E+03 -2.407721E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059670E+05 -7.732569E+04 -2.952267E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 4.70452E-11 sqme_ref* => 8.55502E-11 event_index* => 7 event_weight* => 4.19925E-07 event_weight_ref* => 7.63620E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-3| 2.2444979E+05; 2.1947938E+04, 7.0938465E+04,-2.1181060E+05| 0.0000000E+00| 3) 4 prt(o:3| 2.3396900E+05;-3.8668942E+04,-7.1038262E+04, 2.1954447E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.9090574E+04; 1.2111315E+04, 6.0489990E+03, 1.3460152E+04| 0.0000000E+00| 5) - 6 prt(o:21| 2.2490633E+04; 4.6096893E+03,-5.9492015E+03,-2.1194017E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.909057XE+04; 1.211131XE+04, 6.048999XE+03, 1.346015XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 2.249063XE+04; 4.609689XE+03,-5.949201XE+03,-2.119401XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #7 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 8.55502E-11 Squared matrix el. (prc) = 1.41404E-12 Event weight (ref) = 7.63620E-07 Event weight (prc) = 1.26217E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2042523454.0, 1790911384.0, 3715479539.0, 3582083863.0, 2240445629.0, 3470253870.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.195207E+05 P = 1.239520E+04 7.088145E+04 -2.073922E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.402876E+05 P = -4.887334E+04 -7.109917E+04 2.242642E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019162E+04 P = 3.647814E+04 2.177158E+02 -1.687201E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3203562530.0, 370100846.0, 1647107524.0, 1466280485.0, 4189984473.0, 360074395.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.133485E+03 4.829088E+04 -1.361360E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577453E+04 3.340275E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369713E+04 P = 3.332597E+04 -4.367942E+03 -2.407721E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059670E+05 -7.732569E+04 -2.952267E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.501741013E-12 +sqme_rad = 1.50174101XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.195207E+05 P = 1.239520E+04 7.088145E+04 -2.073922E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.402876E+05 P = -4.887334E+04 -7.109917E+04 2.242642E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019162E+04 P = 3.647814E+04 2.177158E+02 -1.687201E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.244498E+05 P = 2.194794E+04 7.093846E+04 -2.118106E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.339690E+05 P = -3.866894E+04 -7.103826E+04 2.195445E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.909057E+04 P = 1.211131E+04 6.048999E+03 1.346015E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.249063E+04 P = 4.609689E+03 -5.949202E+03 -2.119402E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.604817E+05 P = -1.426073E+04 1.471366E+05 -6.246454E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.668286E+05 P = -4.465708E+04 -4.698866E+04 1.537192E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.984915E+04 P = 3.741064E+04 5.550170E+03 -3.247426E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.228405E+05 P = 2.150718E+04 -1.056981E+05 -5.878044E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.133485E+03 4.829088E+04 -1.361360E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577453E+04 3.340275E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369713E+04 P = 3.332597E+04 -4.367942E+03 -2.407721E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059670E+05 -7.732569E+04 -2.952267E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.41404E-12 sqme_ref* => 8.55502E-11 event_index* => 7 event_weight* => 1.26217E-08 event_weight_ref* => 7.63620E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 1.6048170E+05;-1.4260734E+04, 1.4713663E+05,-6.2464539E+04| 0.0000000E+00| 3) 4 prt(o:1| 1.6682863E+05;-4.4657076E+04,-4.6988656E+04, 1.5371923E+05| 0.0000000E+00| 4) - 5 prt(o:21| 4.9849146E+04; 3.7410636E+04, 5.5501704E+03,-3.2474256E+04| 0.0000000E+00| 5) - 6 prt(o:21| 1.2284053E+05; 2.1507175E+04,-1.0569814E+05,-5.8780439E+04| 0.0000000E+00| 6) + 5 prt(o:21| 4.984914XE+04; 3.741063XE+04, 5.550170XE+03,-3.247425XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 1.228405XE+05; 2.150717XE+04,-1.056981XE+05,-5.878043XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #7 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 8.55502E-11 Squared matrix el. (prc) = 1.50174E-12 Event weight (ref) = 7.63620E-07 Event weight (prc) = 1.34045E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2042523454.0, 1790911384.0, 3715479539.0, 3582083863.0, 2240445629.0, 3470253870.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.195207E+05 P = 1.239520E+04 7.088145E+04 -2.073922E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.402876E+05 P = -4.887334E+04 -7.109917E+04 2.242642E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019162E+04 P = 3.647814E+04 2.177158E+02 -1.687201E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3203562530.0, 370100846.0, 1647107524.0, 1466280485.0, 4189984473.0, 360074395.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.133485E+03 4.829088E+04 -1.361360E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577453E+04 3.340275E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369713E+04 P = 3.332597E+04 -4.367942E+03 -2.407721E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059670E+05 -7.732569E+04 -2.952267E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.501741013E-12 +sqme_rad = 1.50174101XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.195207E+05 P = 1.239520E+04 7.088145E+04 -2.073922E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.402876E+05 P = -4.887334E+04 -7.109917E+04 2.242642E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019162E+04 P = 3.647814E+04 2.177158E+02 -1.687201E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.244498E+05 P = 2.194794E+04 7.093846E+04 -2.118106E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.339690E+05 P = -3.866894E+04 -7.103826E+04 2.195445E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.909057E+04 P = 1.211131E+04 6.048999E+03 1.346015E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.249063E+04 P = 4.609689E+03 -5.949202E+03 -2.119402E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.604817E+05 P = -1.426073E+04 1.471366E+05 -6.246454E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.668286E+05 P = -4.465708E+04 -4.698866E+04 1.537192E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.984915E+04 P = 3.741064E+04 5.550170E+03 -3.247426E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.228405E+05 P = 2.150718E+04 -1.056981E+05 -5.878044E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.133485E+03 4.829088E+04 -1.361360E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577453E+04 3.340275E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369713E+04 P = 3.332597E+04 -4.367942E+03 -2.407721E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059670E+05 -7.732569E+04 -2.952267E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.50174E-12 sqme_ref* => 8.55502E-11 event_index* => 7 event_weight* => 1.34045E-08 event_weight_ref* => 7.63620E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.4448130E+05;-3.1334845E+03, 4.8290883E+04,-1.3613603E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.8736020E+05; 7.5774529E+04, 3.3402753E+04, 1.6806642E+05| 0.0000000E+00| 4) - 5 prt(o:21| 3.3697127E+04; 3.3325971E+04,-4.3679420E+03,-2.4077209E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.3446137E+05;-1.0596702E+05,-7.7325694E+04,-2.9522673E+04| 0.0000000E+00| 6) + 5 prt(o:21| 3.369712XE+04; 3.332597XE+04,-4.367942XE+03,-2.407720XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.344613XE+05;-1.059670XE+05,-7.732569XE+04,-2.952267XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #8 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.79521E-07 Squared matrix el. (prc) = 1.56951E-07 Event weight (ref) = 1.57912E-05 Event weight (prc) = 1.38059E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3361222980.0, 3601284.0, 3842382860.0, 2580515999.0, 3568184670.0, 735623006.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534152E+04 5.389493E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446529E+04 -5.332393E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083083E+03 P = -8.762344E+02 -5.709917E+02 1.801504E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2280904955.0, 1539004561.0, 852756080.0, 3258303332.0, 2415368508.0, 1295976056.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911438E+04 4.032240E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644485E+04 P = 4.529875E+04 7.353456E+04 -3.660889E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750402E+03 P = -9.451482E+02 -7.211946E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346798E+04 -1.131358E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 4.950788956E-12 +sqme_rad = 4.95078895XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534152E+04 5.389493E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446529E+04 -5.332393E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083083E+03 P = -8.762344E+02 -5.709917E+02 1.801504E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.497882E+05 P = 2.527429E+04 5.385111E+04 -2.426014E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.481274E+05 P = -2.453203E+04 -5.336743E+04 2.410753E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.027923E+02 P = 1.805533E+02 9.186207E+01 -9.305257E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.881521E+03 P = -9.228066E+02 -5.755459E+02 1.535349E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 8.895885E+04 P = 2.293109E+04 7.424887E+04 4.330067E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.837066E+05 P = -1.794870E+04 -3.946482E+04 1.785175E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.580182E+03 P = -8.209348E+02 -4.533836E+02 1.271804E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.257544E+05 P = -4.161456E+03 -3.433066E+04 -2.230899E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911438E+04 4.032240E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644485E+04 P = 4.529875E+04 7.353456E+04 -3.660889E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750402E+03 P = -9.451482E+02 -7.211946E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346798E+04 -1.131358E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.56951E-07 sqme_ref* => 1.79521E-07 event_index* => 8 event_weight* => 1.38059E-05 event_weight_ref* => 1.57912E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4993875E+05; 2.5341519E+04, 5.3894925E+04,-2.4273962E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4797816E+05;-2.4465285E+04,-5.3323933E+04, 2.4093812E+05| 0.0000000E+00| 4) - 5 prt(o:21| 2.0830827E+03;-8.7623438E+02,-5.7099168E+02, 1.8015037E+03| 0.0000000E+00| 5) + 5 prt(o:21| 2.083082XE+03;-8.762343XE+02,-5.709916XE+02, 1.801503XE+03| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #8 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.79521E-07 Squared matrix el. (prc) = 2.25624E-08 Event weight (ref) = 1.57912E-05 Event weight (prc) = 1.98466E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3361222980.0, 3601284.0, 3842382860.0, 2580515999.0, 3568184670.0, 735623006.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534152E+04 5.389493E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446529E+04 -5.332393E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083083E+03 P = -8.762344E+02 -5.709917E+02 1.801504E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2280904955.0, 1539004561.0, 852756080.0, 3258303332.0, 2415368508.0, 1295976056.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911438E+04 4.032240E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644485E+04 P = 4.529875E+04 7.353456E+04 -3.660889E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750402E+03 P = -9.451482E+02 -7.211946E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346798E+04 -1.131358E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 4.950788956E-12 +sqme_rad = 4.95078895XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534152E+04 5.389493E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446529E+04 -5.332393E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083083E+03 P = -8.762344E+02 -5.709917E+02 1.801504E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.497882E+05 P = 2.527429E+04 5.385111E+04 -2.426014E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.481274E+05 P = -2.453203E+04 -5.336743E+04 2.410753E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.027923E+02 P = 1.805533E+02 9.186207E+01 -9.305257E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.881521E+03 P = -9.228066E+02 -5.755459E+02 1.535349E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 8.895885E+04 P = 2.293109E+04 7.424887E+04 4.330067E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.837066E+05 P = -1.794870E+04 -3.946482E+04 1.785175E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.580182E+03 P = -8.209348E+02 -4.533836E+02 1.271804E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.257544E+05 P = -4.161456E+03 -3.433066E+04 -2.230899E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911438E+04 4.032240E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644485E+04 P = 4.529875E+04 7.353456E+04 -3.660889E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750402E+03 P = -9.451482E+02 -7.211946E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346798E+04 -1.131358E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.25624E-08 sqme_ref* => 1.79521E-07 event_index* => 8 event_weight* => 1.98466E-06 event_weight_ref* => 1.57912E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4978825E+05; 2.5274285E+04, 5.3851112E+04,-2.4260139E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4812744E+05;-2.4532032E+04,-5.3367429E+04, 2.4107535E+05| 0.0000000E+00| 4) - 5 prt(o:21| 2.0279233E+02; 1.8055332E+02, 9.1862071E+01,-9.3052566E+00| 0.0000000E+00| 5) - 6 prt(o:21| 1.8815211E+03;-9.2280657E+02,-5.7554594E+02, 1.5353490E+03| 0.0000000E+00| 6) + 5 prt(o:21| 2.027923XE+02; 1.805533XE+02, 9.186207XE+01,-9.305256XE+00| 0.000000XE+00| 5) + 6 prt(o:21| 1.881521XE+03;-9.228065XE+02,-5.755459XE+02, 1.535349XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #8 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.79521E-07 Squared matrix el. (prc) = 2.44130E-12 Event weight (ref) = 1.57912E-05 Event weight (prc) = 2.14745E-10 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3361222980.0, 3601284.0, 3842382860.0, 2580515999.0, 3568184670.0, 735623006.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534152E+04 5.389493E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446529E+04 -5.332393E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083083E+03 P = -8.762344E+02 -5.709917E+02 1.801504E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2280904955.0, 1539004561.0, 852756080.0, 3258303332.0, 2415368508.0, 1295976056.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911438E+04 4.032240E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644485E+04 P = 4.529875E+04 7.353456E+04 -3.660889E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750402E+03 P = -9.451482E+02 -7.211946E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346798E+04 -1.131358E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 4.950788956E-12 +sqme_rad = 4.95078895XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534152E+04 5.389493E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446529E+04 -5.332393E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083083E+03 P = -8.762344E+02 -5.709917E+02 1.801504E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.497882E+05 P = 2.527429E+04 5.385111E+04 -2.426014E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.481274E+05 P = -2.453203E+04 -5.336743E+04 2.410753E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.027923E+02 P = 1.805533E+02 9.186207E+01 -9.305257E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.881521E+03 P = -9.228066E+02 -5.755459E+02 1.535349E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 8.895885E+04 P = 2.293109E+04 7.424887E+04 4.330067E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.837066E+05 P = -1.794870E+04 -3.946482E+04 1.785175E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.580182E+03 P = -8.209348E+02 -4.533836E+02 1.271804E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.257544E+05 P = -4.161456E+03 -3.433066E+04 -2.230899E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911438E+04 4.032240E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644485E+04 P = 4.529875E+04 7.353456E+04 -3.660889E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750402E+03 P = -9.451482E+02 -7.211946E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346798E+04 -1.131358E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.44130E-12 sqme_ref* => 1.79521E-07 event_index* => 8 event_weight* => 2.14745E-10 event_weight_ref* => 1.57912E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 8.8958852E+04; 2.2931087E+04, 7.4248867E+04, 4.3300675E+04| 0.0000000E+00| 3) 4 prt(o:2| 1.8370660E+05;-1.7948697E+04,-3.9464818E+04, 1.7851747E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.5801821E+03;-8.2093479E+02,-4.5338362E+02, 1.2718038E+03| 0.0000000E+00| 5) - 6 prt(o:21| 2.2575437E+05;-4.1614559E+03,-3.4330665E+04,-2.2308994E+05| 0.0000000E+00| 6) + 5 prt(o:21| 1.580182XE+03;-8.209347XE+02,-4.533836XE+02, 1.271803XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 2.257543XE+05;-4.161455XE+03,-3.433066XE+04,-2.230899XE+05| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #8 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.79521E-07 Squared matrix el. (prc) = 4.95079E-12 Event weight (ref) = 1.57912E-05 Event weight (prc) = 4.35487E-10 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3361222980.0, 3601284.0, 3842382860.0, 2580515999.0, 3568184670.0, 735623006.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534152E+04 5.389493E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446529E+04 -5.332393E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083083E+03 P = -8.762344E+02 -5.709917E+02 1.801504E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2280904955.0, 1539004561.0, 852756080.0, 3258303332.0, 2415368508.0, 1295976056.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911438E+04 4.032240E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644485E+04 P = 4.529875E+04 7.353456E+04 -3.660889E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750402E+03 P = -9.451482E+02 -7.211946E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346798E+04 -1.131358E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 4.950788956E-12 +sqme_rad = 4.95078895XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534152E+04 5.389493E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446529E+04 -5.332393E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083083E+03 P = -8.762344E+02 -5.709917E+02 1.801504E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.497882E+05 P = 2.527429E+04 5.385111E+04 -2.426014E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.481274E+05 P = -2.453203E+04 -5.336743E+04 2.410753E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.027923E+02 P = 1.805533E+02 9.186207E+01 -9.305257E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.881521E+03 P = -9.228066E+02 -5.755459E+02 1.535349E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 8.895885E+04 P = 2.293109E+04 7.424887E+04 4.330067E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.837066E+05 P = -1.794870E+04 -3.946482E+04 1.785175E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.580182E+03 P = -8.209348E+02 -4.533836E+02 1.271804E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.257544E+05 P = -4.161456E+03 -3.433066E+04 -2.230899E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911438E+04 4.032240E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644485E+04 P = 4.529875E+04 7.353456E+04 -3.660889E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750402E+03 P = -9.451482E+02 -7.211946E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346798E+04 -1.131358E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 4.95079E-12 sqme_ref* => 1.79521E-07 event_index* => 8 event_weight* => 4.35487E-10 event_weight_ref* => 1.57912E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 1.8682126E+05; 1.9114376E+04, 4.0322396E+04,-1.8141370E+05| 0.0000000E+00| 3) 4 prt(o:1| 8.6444845E+04; 4.5298753E+04, 7.3534564E+04,-3.6608886E+03| 0.0000000E+00| 4) - 5 prt(o:21| 2.7504020E+03;-9.4514820E+02,-7.2119456E+02, 2.4801783E+03| 0.0000000E+00| 5) - 6 prt(o:21| 2.2398349E+05;-6.3467980E+04,-1.1313577E+05, 1.8259441E+05| 0.0000000E+00| 6) + 5 prt(o:21| 2.750402XE+03;-9.451482XE+02,-7.211945XE+02, 2.480178XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 2.239834XE+05;-6.346798XE+04,-1.131357XE+05, 1.825944XE+05| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #9 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.02232E-08 Squared matrix el. (prc) = 2.86600E-07 Event weight (ref) = 1.47236E-06 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1484659988.0, 1927671876.0, 4126230753.0, 2962609785.0, 2346280463.0, 1525515485.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499775E+05 P = 3.259522E+03 -8.667161E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.371317E+05 P = -3.747124E+03 8.144607E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.876011E+02 5.225548E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1981754768.0, 1371881432.0, 1113999651.0, 130493356.0, 4030926615.0, 1806134700.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.887497E+03 -7.858541E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030966E+04 8.319833E+04 2.053436E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422645E+04 P = 4.664255E+02 5.685814E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571730E+04 P = -3.366358E+04 -1.029874E+04 -6.035308E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.494551151E-10 +sqme_rad = 1.49455115XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499775E+05 P = 3.259522E+03 -8.667161E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.371317E+05 P = -3.747124E+03 8.144607E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.876011E+02 5.225548E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487096E+05 P = 3.307642E+03 -8.615592E+04 -2.332866E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383402E+05 P = -3.701244E+03 8.193776E+04 2.237823E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.100863E+04 P = 2.292032E+03 4.527698E+03 9.769163E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.941649E+03 P = -1.898431E+03 -3.095330E+02 -2.648597E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.371521E+05 P = -3.308688E+04 -7.653731E+04 -2.220099E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.135807E+05 P = -3.440033E+03 7.328045E+04 2.005863E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.161505E+04 P = 5.042981E+02 4.781571E+03 1.057316E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.765217E+04 P = 3.602261E+04 -1.524710E+03 1.085045E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.887497E+03 -7.858541E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030966E+04 8.319833E+04 2.053436E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422645E+04 P = 4.664255E+02 5.685814E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571730E+04 P = -3.366358E+04 -1.029874E+04 -6.035308E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.86600E-07 sqme_ref* => 1.02232E-08 event_index* => 9 event_weight* => 0.00000E+00 event_weight_ref* => 1.47236E-06 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4997748E+05; 3.2595224E+03,-8.6671615E+04,-2.3444860E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.3713167E+05;-3.7471236E+03, 8.1446067E+04, 2.2267448E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2890852E+04; 4.8760113E+02, 5.2255478E+03, 1.1774122E+04| 0.0000000E+00| 5) + 5 prt(o:21| 1.289085XE+04; 4.876011XE+02, 5.225547XE+03, 1.177412XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #9 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.02232E-08 Squared matrix el. (prc) = 9.93340E-09 Event weight (ref) = 1.47236E-06 Event weight (prc) = 1.43062E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1484659988.0, 1927671876.0, 4126230753.0, 2962609785.0, 2346280463.0, 1525515485.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499775E+05 P = 3.259522E+03 -8.667161E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.371317E+05 P = -3.747124E+03 8.144607E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.876011E+02 5.225548E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1981754768.0, 1371881432.0, 1113999651.0, 130493356.0, 4030926615.0, 1806134700.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.887497E+03 -7.858541E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030966E+04 8.319833E+04 2.053436E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422645E+04 P = 4.664255E+02 5.685814E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571730E+04 P = -3.366358E+04 -1.029874E+04 -6.035308E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.494551151E-10 +sqme_rad = 1.49455115XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499775E+05 P = 3.259522E+03 -8.667161E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.371317E+05 P = -3.747124E+03 8.144607E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.876011E+02 5.225548E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487096E+05 P = 3.307642E+03 -8.615592E+04 -2.332866E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383402E+05 P = -3.701244E+03 8.193776E+04 2.237823E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.100863E+04 P = 2.292032E+03 4.527698E+03 9.769163E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.941649E+03 P = -1.898431E+03 -3.095330E+02 -2.648597E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.371521E+05 P = -3.308688E+04 -7.653731E+04 -2.220099E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.135807E+05 P = -3.440033E+03 7.328045E+04 2.005863E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.161505E+04 P = 5.042981E+02 4.781571E+03 1.057316E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.765217E+04 P = 3.602261E+04 -1.524710E+03 1.085045E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.887497E+03 -7.858541E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030966E+04 8.319833E+04 2.053436E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422645E+04 P = 4.664255E+02 5.685814E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571730E+04 P = -3.366358E+04 -1.029874E+04 -6.035308E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 9.93340E-09 sqme_ref* => 1.02232E-08 event_index* => 9 event_weight* => 1.43062E-06 event_weight_ref* => 1.47236E-06 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.4870956E+05; 3.3076425E+03,-8.6155920E+04,-2.3328665E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.3834016E+05;-3.7012437E+03, 8.1937755E+04, 2.2378234E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.1008633E+04; 2.2920320E+03, 4.5276979E+03, 9.7691629E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.9416490E+03;-1.8984308E+03,-3.0953299E+02,-2.6485975E+02| 0.0000000E+00| 6) + 5 prt(o:21| 1.100863XE+04; 2.292032XE+03, 4.527697XE+03, 9.769162XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.941649XE+03;-1.898430XE+03,-3.095329XE+02,-2.648597XE+02| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #9 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.02232E-08 Squared matrix el. (prc) = 1.40316E-10 Event weight (ref) = 1.47236E-06 Event weight (prc) = 2.02086E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1484659988.0, 1927671876.0, 4126230753.0, 2962609785.0, 2346280463.0, 1525515485.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499775E+05 P = 3.259522E+03 -8.667161E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.371317E+05 P = -3.747124E+03 8.144607E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.876011E+02 5.225548E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1981754768.0, 1371881432.0, 1113999651.0, 130493356.0, 4030926615.0, 1806134700.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.887497E+03 -7.858541E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030966E+04 8.319833E+04 2.053436E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422645E+04 P = 4.664255E+02 5.685814E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571730E+04 P = -3.366358E+04 -1.029874E+04 -6.035308E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.494551151E-10 +sqme_rad = 1.49455115XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499775E+05 P = 3.259522E+03 -8.667161E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.371317E+05 P = -3.747124E+03 8.144607E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.876011E+02 5.225548E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487096E+05 P = 3.307642E+03 -8.615592E+04 -2.332866E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383402E+05 P = -3.701244E+03 8.193776E+04 2.237823E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.100863E+04 P = 2.292032E+03 4.527698E+03 9.769163E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.941649E+03 P = -1.898431E+03 -3.095330E+02 -2.648597E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.371521E+05 P = -3.308688E+04 -7.653731E+04 -2.220099E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.135807E+05 P = -3.440033E+03 7.328045E+04 2.005863E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.161505E+04 P = 5.042981E+02 4.781571E+03 1.057316E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.765217E+04 P = 3.602261E+04 -1.524710E+03 1.085045E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.887497E+03 -7.858541E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030966E+04 8.319833E+04 2.053436E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422645E+04 P = 4.664255E+02 5.685814E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571730E+04 P = -3.366358E+04 -1.029874E+04 -6.035308E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.40316E-10 sqme_ref* => 1.02232E-08 event_index* => 9 event_weight* => 2.02086E-08 event_weight_ref* => 1.47236E-06 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.3715207E+05;-3.3086878E+04,-7.6537309E+04,-2.2200991E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.1358072E+05;-3.4400332E+03, 7.3280448E+04, 2.0058630E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.1615049E+04; 5.0429809E+02, 4.7815710E+03, 1.0573155E+04| 0.0000000E+00| 5) - 6 prt(o:21| 3.7652168E+04; 3.6022614E+04,-1.5247103E+03, 1.0850452E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.161504XE+04; 5.042980XE+02, 4.781571XE+03, 1.057315XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 3.765216XE+04; 3.602261XE+04,-1.524710XE+03, 1.085045XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #9 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.02232E-08 Squared matrix el. (prc) = 1.49455E-10 Event weight (ref) = 1.47236E-06 Event weight (prc) = 2.15248E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1484659988.0, 1927671876.0, 4126230753.0, 2962609785.0, 2346280463.0, 1525515485.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499775E+05 P = 3.259522E+03 -8.667161E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.371317E+05 P = -3.747124E+03 8.144607E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.876011E+02 5.225548E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1981754768.0, 1371881432.0, 1113999651.0, 130493356.0, 4030926615.0, 1806134700.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.887497E+03 -7.858541E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030966E+04 8.319833E+04 2.053436E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422645E+04 P = 4.664255E+02 5.685814E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571730E+04 P = -3.366358E+04 -1.029874E+04 -6.035308E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.494551151E-10 +sqme_rad = 1.49455115XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499775E+05 P = 3.259522E+03 -8.667161E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.371317E+05 P = -3.747124E+03 8.144607E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.876011E+02 5.225548E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487096E+05 P = 3.307642E+03 -8.615592E+04 -2.332866E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383402E+05 P = -3.701244E+03 8.193776E+04 2.237823E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.100863E+04 P = 2.292032E+03 4.527698E+03 9.769163E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.941649E+03 P = -1.898431E+03 -3.095330E+02 -2.648597E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.371521E+05 P = -3.308688E+04 -7.653731E+04 -2.220099E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.135807E+05 P = -3.440033E+03 7.328045E+04 2.005863E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.161505E+04 P = 5.042981E+02 4.781571E+03 1.057316E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.765217E+04 P = 3.602261E+04 -1.524710E+03 1.085045E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.887497E+03 -7.858541E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030966E+04 8.319833E+04 2.053436E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422645E+04 P = 4.664255E+02 5.685814E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571730E+04 P = -3.366358E+04 -1.029874E+04 -6.035308E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.49455E-10 sqme_ref* => 1.02232E-08 event_index* => 9 event_weight* => 2.15248E-08 event_weight_ref* => 1.47236E-06 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.2643459E+05; 2.8874968E+03,-7.8585406E+04,-2.1234081E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.2362165E+05; 3.0309660E+04, 8.3198329E+04, 2.0534363E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.4226452E+04; 4.6642548E+02, 5.6858136E+03, 1.3032494E+04| 0.0000000E+00| 5) - 6 prt(o:21| 3.5717302E+04;-3.3663582E+04,-1.0298737E+04,-6.0353076E+03| 0.0000000E+00| 6) + 5 prt(o:21| 1.422645XE+04; 4.664254XE+02, 5.685813XE+03, 1.303249XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 3.571730XE+04;-3.366358XE+04,-1.029873XE+04,-6.035307XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #10 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 4.92773E-09 Squared matrix el. (prc) = 7.74653E-07 Event weight (ref) = 1.03136E-04 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2574779949.0, 1613258.0, 957203242.0, 1832886249.0, 3404761797.0, 1098311093.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189026E+05 2.145968E+05 4.753746E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114467E+05 -1.954008E+05 -4.348273E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098857E+04 P = -7.455888E+03 -1.919606E+04 -4.054732E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 379220129.0, 955940867.0, 625050135.0, 1046562733.0, 2664737320.0, 326107529.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434708E+05 P = 1.157756E+05 2.091142E+05 4.631741E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217268E+05 P = -9.967986E+04 -1.951839E+05 -3.361475E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153699E+04 P = -7.725418E+03 -1.966863E+04 -4.159893E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326535E+04 P = -8.370322E+03 5.738335E+03 -8.542763E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 5.292983914E-10 +sqme_rad = 5.29298391XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189026E+05 2.145968E+05 4.753746E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114467E+05 -1.954008E+05 -4.348273E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098857E+04 P = -7.455888E+03 -1.919606E+04 -4.054732E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.493156E+05 P = 1.186936E+05 2.140586E+05 4.742378E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.296477E+05 P = -1.116388E+05 -1.958953E+05 -4.358720E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982150E+04 P = -6.219297E+03 -1.857109E+04 -3.053985E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.215214E+03 P = -8.354473E+02 4.078253E+02 -7.825921E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.424422E+05 P = 1.046411E+05 2.116191E+05 5.518882E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.226841E+05 P = -1.083878E+05 -1.898800E+05 -4.225976E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.040490E+04 P = -7.175630E+03 -1.869025E+04 -3.942684E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.446885E+04 P = 1.092232E+04 -3.048900E+03 -8.986373E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434708E+05 P = 1.157756E+05 2.091142E+05 4.631741E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217268E+05 P = -9.967986E+04 -1.951839E+05 -3.361475E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153699E+04 P = -7.725418E+03 -1.966863E+04 -4.159893E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326535E+04 P = -8.370322E+03 5.738335E+03 -8.542763E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 7.74653E-07 sqme_ref* => 4.92773E-09 event_index* => 10 event_weight* => 0.00000E+00 event_weight_ref* => 1.03136E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4989885E+05; 1.1890261E+05, 2.1459682E+05, 4.7537459E+04| 0.0000000E+00| 3) 4 prt(o:2| 2.2911258E+05;-1.1144672E+05,-1.9540076E+05,-4.3482727E+04| 0.0000000E+00| 4) - 5 prt(o:21| 2.0988566E+04;-7.4558885E+03,-1.9196062E+04,-4.0547316E+03| 0.0000000E+00| 5) + 5 prt(o:21| 2.098856XE+04;-7.455888XE+03,-1.919606XE+04,-4.054731XE+03| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #10 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 4.92773E-09 Squared matrix el. (prc) = 3.94878E-09 Event weight (ref) = 1.03136E-04 Event weight (prc) = 8.26470E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2574779949.0, 1613258.0, 957203242.0, 1832886249.0, 3404761797.0, 1098311093.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189026E+05 2.145968E+05 4.753746E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114467E+05 -1.954008E+05 -4.348273E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098857E+04 P = -7.455888E+03 -1.919606E+04 -4.054732E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 379220129.0, 955940867.0, 625050135.0, 1046562733.0, 2664737320.0, 326107529.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434708E+05 P = 1.157756E+05 2.091142E+05 4.631741E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217268E+05 P = -9.967986E+04 -1.951839E+05 -3.361475E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153699E+04 P = -7.725418E+03 -1.966863E+04 -4.159893E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326535E+04 P = -8.370322E+03 5.738335E+03 -8.542763E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 5.292983914E-10 +sqme_rad = 5.29298391XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189026E+05 2.145968E+05 4.753746E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114467E+05 -1.954008E+05 -4.348273E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098857E+04 P = -7.455888E+03 -1.919606E+04 -4.054732E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.493156E+05 P = 1.186936E+05 2.140586E+05 4.742378E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.296477E+05 P = -1.116388E+05 -1.958953E+05 -4.358720E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982150E+04 P = -6.219297E+03 -1.857109E+04 -3.053985E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.215214E+03 P = -8.354473E+02 4.078253E+02 -7.825921E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.424422E+05 P = 1.046411E+05 2.116191E+05 5.518882E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.226841E+05 P = -1.083878E+05 -1.898800E+05 -4.225976E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.040490E+04 P = -7.175630E+03 -1.869025E+04 -3.942684E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.446885E+04 P = 1.092232E+04 -3.048900E+03 -8.986373E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434708E+05 P = 1.157756E+05 2.091142E+05 4.631741E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217268E+05 P = -9.967986E+04 -1.951839E+05 -3.361475E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153699E+04 P = -7.725418E+03 -1.966863E+04 -4.159893E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326535E+04 P = -8.370322E+03 5.738335E+03 -8.542763E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.94878E-09 sqme_ref* => 4.92773E-09 event_index* => 10 event_weight* => 8.26470E-05 event_weight_ref* => 1.03136E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4931560E+05; 1.1869356E+05, 2.1405862E+05, 4.7423776E+04| 0.0000000E+00| 3) 4 prt(o:2| 2.2964768E+05;-1.1163882E+05,-1.9589535E+05,-4.3587198E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.9821503E+04;-6.2192966E+03,-1.8571093E+04,-3.0539853E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.2152136E+03;-8.3544734E+02, 4.0782529E+02,-7.8259212E+02| 0.0000000E+00| 6) + 5 prt(o:21| 1.982150XE+04;-6.219296XE+03,-1.857109XE+04,-3.053985XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.215213XE+03;-8.354473XE+02, 4.078252XE+02,-7.825921XE+02| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #10 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 4.92773E-09 Squared matrix el. (prc) = 4.49647E-10 Event weight (ref) = 1.03136E-04 Event weight (prc) = 9.41100E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2574779949.0, 1613258.0, 957203242.0, 1832886249.0, 3404761797.0, 1098311093.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189026E+05 2.145968E+05 4.753746E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114467E+05 -1.954008E+05 -4.348273E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098857E+04 P = -7.455888E+03 -1.919606E+04 -4.054732E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 379220129.0, 955940867.0, 625050135.0, 1046562733.0, 2664737320.0, 326107529.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434708E+05 P = 1.157756E+05 2.091142E+05 4.631741E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217268E+05 P = -9.967986E+04 -1.951839E+05 -3.361475E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153699E+04 P = -7.725418E+03 -1.966863E+04 -4.159893E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326535E+04 P = -8.370322E+03 5.738335E+03 -8.542763E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 5.292983914E-10 +sqme_rad = 5.29298391XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189026E+05 2.145968E+05 4.753746E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114467E+05 -1.954008E+05 -4.348273E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098857E+04 P = -7.455888E+03 -1.919606E+04 -4.054732E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.493156E+05 P = 1.186936E+05 2.140586E+05 4.742378E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.296477E+05 P = -1.116388E+05 -1.958953E+05 -4.358720E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982150E+04 P = -6.219297E+03 -1.857109E+04 -3.053985E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.215214E+03 P = -8.354473E+02 4.078253E+02 -7.825921E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.424422E+05 P = 1.046411E+05 2.116191E+05 5.518882E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.226841E+05 P = -1.083878E+05 -1.898800E+05 -4.225976E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.040490E+04 P = -7.175630E+03 -1.869025E+04 -3.942684E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.446885E+04 P = 1.092232E+04 -3.048900E+03 -8.986373E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434708E+05 P = 1.157756E+05 2.091142E+05 4.631741E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217268E+05 P = -9.967986E+04 -1.951839E+05 -3.361475E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153699E+04 P = -7.725418E+03 -1.966863E+04 -4.159893E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326535E+04 P = -8.370322E+03 5.738335E+03 -8.542763E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 4.49647E-10 sqme_ref* => 4.92773E-09 event_index* => 10 event_weight* => 9.41100E-06 event_weight_ref* => 1.03136E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4244218E+05; 1.0464109E+05, 2.1161910E+05, 5.5188817E+04| 0.0000000E+00| 3) 4 prt(o:2| 2.2268407E+05;-1.0838778E+05,-1.8987996E+05,-4.2259760E+04| 0.0000000E+00| 4) - 5 prt(o:21| 2.0404896E+04;-7.1756298E+03,-1.8690248E+04,-3.9426837E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.4468853E+04; 1.0922318E+04,-3.0488996E+03,-8.9863732E+03| 0.0000000E+00| 6) + 5 prt(o:21| 2.040489XE+04;-7.175629XE+03,-1.869024XE+04,-3.942683XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.446885XE+04; 1.092231XE+04,-3.048899XE+03,-8.986373XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #10 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 4.92773E-09 Squared matrix el. (prc) = 5.29298E-10 Event weight (ref) = 1.03136E-04 Event weight (prc) = 1.10781E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2574779949.0, 1613258.0, 957203242.0, 1832886249.0, 3404761797.0, 1098311093.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189026E+05 2.145968E+05 4.753746E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114467E+05 -1.954008E+05 -4.348273E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098857E+04 P = -7.455888E+03 -1.919606E+04 -4.054732E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 379220129.0, 955940867.0, 625050135.0, 1046562733.0, 2664737320.0, 326107529.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434708E+05 P = 1.157756E+05 2.091142E+05 4.631741E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217268E+05 P = -9.967986E+04 -1.951839E+05 -3.361475E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153699E+04 P = -7.725418E+03 -1.966863E+04 -4.159893E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326535E+04 P = -8.370322E+03 5.738335E+03 -8.542763E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 5.292983914E-10 +sqme_rad = 5.29298391XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189026E+05 2.145968E+05 4.753746E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114467E+05 -1.954008E+05 -4.348273E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098857E+04 P = -7.455888E+03 -1.919606E+04 -4.054732E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.493156E+05 P = 1.186936E+05 2.140586E+05 4.742378E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.296477E+05 P = -1.116388E+05 -1.958953E+05 -4.358720E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982150E+04 P = -6.219297E+03 -1.857109E+04 -3.053985E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.215214E+03 P = -8.354473E+02 4.078253E+02 -7.825921E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.424422E+05 P = 1.046411E+05 2.116191E+05 5.518882E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.226841E+05 P = -1.083878E+05 -1.898800E+05 -4.225976E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.040490E+04 P = -7.175630E+03 -1.869025E+04 -3.942684E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.446885E+04 P = 1.092232E+04 -3.048900E+03 -8.986373E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434708E+05 P = 1.157756E+05 2.091142E+05 4.631741E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217268E+05 P = -9.967986E+04 -1.951839E+05 -3.361475E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153699E+04 P = -7.725418E+03 -1.966863E+04 -4.159893E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326535E+04 P = -8.370322E+03 5.738335E+03 -8.542763E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 5.29298E-10 sqme_ref* => 4.92773E-09 event_index* => 10 event_weight* => 1.10781E-05 event_weight_ref* => 1.03136E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.4347083E+05; 1.1577560E+05, 2.0911421E+05, 4.6317408E+04| 0.0000000E+00| 3) 4 prt(o:1| 2.2172683E+05;-9.9679863E+04,-1.9518391E+05,-3.3614752E+04| 0.0000000E+00| 4) - 5 prt(o:21| 2.1536987E+04;-7.7254178E+03,-1.9668631E+04,-4.1598928E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.3265353E+04;-8.3703215E+03, 5.7383354E+03,-8.5427632E+03| 0.0000000E+00| 6) + 5 prt(o:21| 2.153698XE+04;-7.725417XE+03,-1.966863XE+04,-4.159892XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.326535XE+04;-8.370321XE+03, 5.738335XE+03,-8.542763XE+03| 0.000000XE+00| 6) ======================================================================== Index: trunk/share/tests/functional_tests/ref-output-ext/openloops_12.ref =================================================================== --- trunk/share/tests/functional_tests/ref-output-ext/openloops_12.ref (revision 8839) +++ trunk/share/tests/functional_tests/ref-output-ext/openloops_12.ref (revision 8840) @@ -1,11126 +1,11126 @@ ?openmp_logging = false ?vis_history = false ?integration_timer = false ?pacify = true | Switching to model 'SM', scheme 'GF_MW_MZ' $blha_ew_scheme = "alpha_qed" SM.mZ => 9.11880E+01 SM.mW => 8.04190E+01 SM.mH => 1.25000E+02 SM.GF => 1.16639E-05 SM.wZ => 0.00000E+00 SM.wtop => 0.00000E+00 SM.wW => 0.00000E+00 SM.wH => 0.00000E+00 SM.ms => 0.00000E+00 SM.mc => 0.00000E+00 SM.mb => 0.00000E+00 SM.mtop => 1.73200E+02 SM.me => 0.00000E+00 SM.mmu => 0.00000E+00 SM.mtau => 1.77700E+00 SM.alphas => 1.18000E-01 ?alphas_is_fixed = false ?alphas_from_mz = true ?alphas_from_lambda_qcd = false alphas_nf = 5 [user variable] jet = PDG(2, -2, 1, -1, 3, -3, 21) $exclude_gauge_splittings = "c:b:t" $method = "openloops" alpha_power = 2 alphas_power = 1 $openloops_allowed_libs = "ppllj" ?use_vamp_equivalences = false $integration_method = "vamp2" $rng_method = "rng_stream" openmp_num_threads = 1 jet_algorithm = 2 jet_r = 5.00000E-01 seed = 99 sqrts = 5.00000E+05 | Process library 'openloops_12_lib': recorded process 'openloops_12_p1' | Integrate: current process library needs compilation | Process library 'openloops_12_lib': compiling ... | Process library 'openloops_12_lib': writing makefile | Process library 'openloops_12_lib': removing old files | Process library 'openloops_12_lib': writing driver | Process library 'openloops_12_lib': creating source code | Process library 'openloops_12_lib': compiling sources | Process library 'openloops_12_lib': linking | Process library 'openloops_12_lib': loading | Process library 'openloops_12_lib': ... success. | Integrate: compilation done | QCD alpha: using a running strong coupling | RNG: Initializing RNG Stream random-number generator | RNG: Setting seed for random-number generator to 99 | Initializing integration for process openloops_12_p1: | Beam structure: [any particles] | Beam data (collision): | e- (mass = 0.0000000E+00 GeV) | e+ (mass = 0.0000000E+00 GeV) | sqrts = 5.000000000000E+05 GeV | Phase space: generating configuration ... Warning: Intermediate decay of zero-width particle Z may be possible. | Phase space: ... success. | Phase space: writing configuration file 'openloops_12_p1.i1.phs' | Phase space: generating configuration ... | Phase space: ... success. | Phase space: writing configuration file 'openloops_12_p1.i3.phs' | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | ------------------------------------------------------------------------ | Process [scattering]: 'openloops_12_p1' | Library name = 'openloops_12_lib' | Process index = 1 | Process components: | 1: 'openloops_12_p1_i1': e-, e+ => u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl [inactive] | 2: 'openloops_12_p1_i2': e-, e+ => d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl [openloops], [real] | 3: 'openloops_12_p1_i3': e-, e+ => u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl [inactive], [virtual] | 4: 'openloops_12_p1_i4': e-, e+ => u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl [inactive], [subtraction] | ------------------------------------------------------------------------ | Phase space: 2 channels, 5 dimensions | Phase space: found 2 channels, collected in 1 grove. | Phase space: no equivalences between channels used. | Phase space: wood | Phase space: 2 channels, 8 dimensions | Phase space: found 2 channels, collected in 1 grove. | Phase space: no equivalences between channels used. | Phase space: wood | Phase space: 2 channels, 5 dimensions | Phase space: found 2 channels, collected in 1 grove. | Phase space: no equivalences between channels used. | Phase space: wood | Applying user-defined cuts. | Using user-defined general scale. | Starting integration for process 'openloops_12_p1' part 'real' | Integrate: iterations = 1:100:"gw" | Integrator: 1 chains, 2 channels, 8 dimensions | Integrator: Write grid header and grids to 'openloops_12_p1.m2.vg2' | Integrator: Grid checkpoint after each iteration | Integrator: 100 initial calls, 20 max. bins, stratified = T | Integrator: VAMP2 |=============================================================================| | It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] | |=============================================================================| | VAMP2: Initialize new grids and write to file 'openloops_12_p1.m2.vg2'. | VAMP2: set chain: use chained weights. 1 100 9.645E-04 4.01E-04 41.60 4.16 5.0 |-----------------------------------------------------------------------------| 1 100 9.645E-04 4.01E-04 41.60 4.16 5.0 |=============================================================================| | Integrate: sum of all components |=============================================================================| | It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] | |=============================================================================| 1 0 9.645E-04 4.01E-04 41.60 0.00 5.0 |=============================================================================| n_events = 10 $sample_normalization = "sigma" ?unweighted = false ?negative_weights = true ?keep_failed_events = true ?fixed_order_nlo_events = true ?debug_decay = false ?debug_process = false ?debug_verbose = false ?sample_pacify = true ?write_raw = false | Starting simulation for process 'openloops_12_p1' | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | One-Loop-Provider: Using OpenLoops | Loading library: [...] | Simulate: activating fixed-order NLO events | QCD alpha: using a running strong coupling | RNG: Initializing RNG Stream random-number generator | RNG: Setting seed for random-number generator to 100 | Events: writing to ASCII file 'openloops_12_p1.debug' | Events: generating 40 weighted, unpolarized NLO events ... | Events: event normalization mode 'sigma' | ... event sample complete. | Events: closing ASCII file 'openloops_12_p1.debug' | There were no errors and 1 warning(s). | WHIZARD run finished. |=============================================================================| Total number of regions: 18 alr || flst_real || i_real || em || mul || nreg || ftuples || flst_born || i_born || corr 1 || [ 11,-11, -2, 2, -2, 2] || 1 || 5 || 4 || 4 || {(3,4),(3,6),(4,5),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 2 || [ 11,-11, -2, 2, 21, 21] || 2 || 3 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 3 || [ 11,-11, -2, 2, 21, 21] || 2 || 4 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 4 || [ 11,-11, -2, 2, 21, 21] || 2 || 5 || 1 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 5 || [ 11,-11, -2, 2, -3, 3] || 3 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 6 || [ 11,-11, -3, 3, -2, 2] || 4 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 7 || [ 11,-11, -2, 2, -1, 1] || 5 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -2, 2, 21] || 1 || qcd 8 || [ 11,-11, -1, 1, -2, 2] || 6 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 9 || [ 11,-11, -3, 3, -3, 3] || 7 || 5 || 4 || 4 || {(3,4),(3,6),(4,5),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 10 || [ 11,-11, -3, 3, -1, 1] || 8 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 11 || [ 11,-11, -1, 1, -3, 3] || 9 || 5 || 1 || 2 || {(3,4),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 12 || [ 11,-11, -3, 3, 21, 21] || 10 || 3 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 13 || [ 11,-11, -3, 3, 21, 21] || 10 || 4 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 14 || [ 11,-11, -3, 3, 21, 21] || 10 || 5 || 1 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -3, 3, 21] || 2 || qcd 15 || [ 11,-11, -1, 1, -1, 1] || 11 || 5 || 4 || 4 || {(3,4),(3,6),(4,5),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 16 || [ 11,-11, -1, 1, 21, 21] || 12 || 3 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 17 || [ 11,-11, -1, 1, 21, 21] || 12 || 4 || 2 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd 18 || [ 11,-11, -1, 1, 21, 21] || 12 || 5 || 1 || 5 || {(3,5),(3,6),(4,5),(4,6),(5,6)} || [ 11,-11, -1, 1, 21] || 3 || qcd ------------------------------------------------------------------------ Contents of openloops_12_p1.debug: ======================================================================== Event #1 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 3.89241E-10 Squared matrix el. (prc) = -2.49037E-07 Event weight (ref) = 1.60826E-08 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3913894726.0, 1013504363.0, 4004029631.0, 3745048320.0, 2602019895.0, 3943078012.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-3) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 691625295.0, 3378437961.0, 1571131719.0, 108026903.0, 3340318134.0, 3620710479.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.141170135E-12 +sqme_rad = 2.14117013XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.468486E+05 P = 4.791335E+04 -4.923417E+04 -2.370961E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.400985E+05 P = -4.639184E+04 4.815715E+04 2.305992E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.660191E+03 P = -3.451326E+03 2.749984E+03 -1.497770E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.392675E+03 P = 1.929819E+03 -1.672961E+03 7.994623E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.817300E+05 P = -8.851315E+04 7.882993E+04 -1.377572E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.479079E+05 P = -2.836791E+04 2.993464E+04 1.420419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 8.073434E+03 P = -1.964125E+03 1.092270E+03 7.754321E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.622888E+05 P = 1.188452E+05 -1.098568E+05 -1.203907E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => -2.49037E-07 sqme_ref* => 3.89241E-10 event_index* => 1 event_weight* => 0.00000E+00 event_weight_ref* => 1.60826E-08 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4999146E+05; 4.8621734E+04,-4.9735609E+04,-2.4012086E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.3708037E+05;-4.5711494E+04, 4.7675549E+04, 2.2769410E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2928173E+04;-2.9102400E+03, 2.0600599E+03, 1.2426758E+04| 0.0000000E+00| 5) + 5 prt(o:21| 1.292817XE+04;-2.910240XE+03, 2.060059XE+03, 1.242675XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #1 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 3.89241E-10 Squared matrix el. (prc) = 3.85037E-10 Event weight (ref) = 1.60826E-08 Event weight (prc) = 1.59089E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3913894726.0, 1013504363.0, 4004029631.0, 3745048320.0, 2602019895.0, 3943078012.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-3) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 691625295.0, 3378437961.0, 1571131719.0, 108026903.0, 3340318134.0, 3620710479.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.141170135E-12 +sqme_rad = 2.14117013XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.468486E+05 P = 4.791335E+04 -4.923417E+04 -2.370961E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.400985E+05 P = -4.639184E+04 4.815715E+04 2.305992E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.660191E+03 P = -3.451326E+03 2.749984E+03 -1.497770E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.392675E+03 P = 1.929819E+03 -1.672961E+03 7.994623E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.817300E+05 P = -8.851315E+04 7.882993E+04 -1.377572E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.479079E+05 P = -2.836791E+04 2.993464E+04 1.420419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 8.073434E+03 P = -1.964125E+03 1.092270E+03 7.754321E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.622888E+05 P = 1.188452E+05 -1.098568E+05 -1.203907E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.85037E-10 sqme_ref* => 3.89241E-10 event_index* => 1 event_weight* => 1.59089E-08 event_weight_ref* => 1.60826E-08 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.4684860E+05; 4.7913352E+04,-4.9234169E+04,-2.3709605E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.4009853E+05;-4.6391844E+04, 4.8157146E+04, 2.3059920E+05| 0.0000000E+00| 4) - 5 prt(o:21| 4.6601911E+03;-3.4513264E+03, 2.7499842E+03,-1.4977696E+03| 0.0000000E+00| 5) - 6 prt(o:21| 8.3926755E+03; 1.9298191E+03,-1.6729609E+03, 7.9946233E+03| 0.0000000E+00| 6) + 5 prt(o:21| 4.660191XE+03;-3.451326XE+03, 2.749984XE+03,-1.497769XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 8.392675XE+03; 1.929819XE+03,-1.672960XE+03, 7.994623XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #1 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 3.89241E-10 Squared matrix el. (prc) = 2.06251E-12 Event weight (ref) = 1.60826E-08 Event weight (prc) = 8.52183E-11 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3913894726.0, 1013504363.0, 4004029631.0, 3745048320.0, 2602019895.0, 3943078012.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-3) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 691625295.0, 3378437961.0, 1571131719.0, 108026903.0, 3340318134.0, 3620710479.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.141170135E-12 +sqme_rad = 2.14117013XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.468486E+05 P = 4.791335E+04 -4.923417E+04 -2.370961E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.400985E+05 P = -4.639184E+04 4.815715E+04 2.305992E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.660191E+03 P = -3.451326E+03 2.749984E+03 -1.497770E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.392675E+03 P = 1.929819E+03 -1.672961E+03 7.994623E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.817300E+05 P = -8.851315E+04 7.882993E+04 -1.377572E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.479079E+05 P = -2.836791E+04 2.993464E+04 1.420419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 8.073434E+03 P = -1.964125E+03 1.092270E+03 7.754321E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.622888E+05 P = 1.188452E+05 -1.098568E+05 -1.203907E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.06251E-12 sqme_ref* => 3.89241E-10 event_index* => 1 event_weight* => 8.52183E-11 event_weight_ref* => 1.60826E-08 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 1.8172996E+05;-8.8513148E+04, 7.8829927E+04,-1.3775719E+05| 0.0000000E+00| 3) 4 prt(o:1| 1.4790785E+05;-2.8367908E+04, 2.9934639E+04, 1.4204194E+05| 0.0000000E+00| 4) - 5 prt(o:21| 8.0734344E+03;-1.9641249E+03, 1.0922702E+03, 7.7543215E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.6228876E+05; 1.1884518E+05,-1.0985684E+05,-1.2039071E+04| 0.0000000E+00| 6) + 5 prt(o:21| 8.073434XE+03;-1.964124XE+03, 1.092270XE+03, 7.754321XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.622887XE+05; 1.188451XE+05,-1.098568XE+05,-1.203907XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #1 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 3.89241E-10 Squared matrix el. (prc) = 2.14117E-12 Event weight (ref) = 1.60826E-08 Event weight (prc) = 8.84686E-11 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3913894726.0, 1013504363.0, 4004029631.0, 3745048320.0, 2602019895.0, 3943078012.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-3) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 691625295.0, 3378437961.0, 1571131719.0, 108026903.0, 3340318134.0, 3620710479.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.141170135E-12 +sqme_rad = 2.14117013XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499915E+05 P = 4.862173E+04 -4.973561E+04 -2.401209E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.370804E+05 P = -4.571149E+04 4.767555E+04 2.276941E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.292817E+04 P = -2.910240E+03 2.060060E+03 1.242676E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.468486E+05 P = 4.791335E+04 -4.923417E+04 -2.370961E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.400985E+05 P = -4.639184E+04 4.815715E+04 2.305992E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.660191E+03 P = -3.451326E+03 2.749984E+03 -1.497770E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.392675E+03 P = 1.929819E+03 -1.672961E+03 7.994623E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.817300E+05 P = -8.851315E+04 7.882993E+04 -1.377572E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.479079E+05 P = -2.836791E+04 2.993464E+04 1.420419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 8.073434E+03 P = -1.964125E+03 1.092270E+03 7.754321E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.622888E+05 P = 1.188452E+05 -1.098568E+05 -1.203907E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.629667E+05 P = 3.184238E+04 -3.223531E+04 -1.565410E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.633022E+05 P = -1.040587E+05 1.195116E+05 3.945081E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982397E+04 P = -4.241028E+03 3.448027E+03 1.905556E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.539072E+05 P = 7.645734E+04 -9.072433E+04 9.803463E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.14117E-12 sqme_ref* => 3.89241E-10 event_index* => 1 event_weight* => 8.84686E-11 event_weight_ref* => 1.60826E-08 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.6296668E+05; 3.1842380E+04,-3.2235307E+04,-1.5654100E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.6330218E+05;-1.0405869E+05, 1.1951161E+05, 3.9450809E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.9823968E+04;-4.2410282E+03, 3.4480271E+03, 1.9055564E+04| 0.0000000E+00| 5) - 6 prt(o:21| 1.5390717E+05; 7.6457341E+04,-9.0724330E+04, 9.8034630E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.982396XE+04;-4.241028XE+03, 3.448027XE+03, 1.905556XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 1.539071XE+05; 7.645734XE+04,-9.072433XE+04, 9.803463XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #2 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.99461E-09 Squared matrix el. (prc) = -5.90914E-08 Event weight (ref) = 6.26874E-05 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2566007711.0, 2240170159.0, 3022189282.0, 484554216.0, 1681294000.0, 1422185293.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3393932940.0, 2952039924.0, 1817149397.0, 3151505971.0, 2985798367.0, 2791898150.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 6.319084949E-11 +sqme_rad = 6.31908494XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487563E+05 P = 1.447377E+04 1.072132E+05 -2.239990E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383998E+05 P = -1.265869E+04 -1.014761E+05 2.153528E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.001283E+04 P = -1.661639E+03 -7.492873E+03 6.430601E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.831067E+03 P = -1.534389E+02 1.755770E+03 2.215551E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.174964E+05 P = -7.025912E+03 4.712115E+04 -2.122144E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.155529E+05 P = -1.119089E+04 -9.148298E+04 1.948555E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.163656E+04 P = -2.134855E+03 -6.459096E+03 9.440977E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.531409E+04 P = 2.035166E+04 5.082092E+04 7.917847E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => -5.90914E-08 sqme_ref* => 2.99461E-09 event_index* => 2 event_weight* => 0.00000E+00 event_weight_ref* => 6.26874E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4989224E+05; 1.4672701E+04, 1.0784194E+05,-2.2494657E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.3731786E+05;-1.2468913E+04,-1.0087620E+05, 2.1444879E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2789898E+04;-2.2037877E+03,-6.9657375E+03, 1.0497777E+04| 0.0000000E+00| 5) + 5 prt(o:21| 1.278989XE+04;-2.203787XE+03,-6.965737XE+03, 1.049777XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #2 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.99461E-09 Squared matrix el. (prc) = 2.87907E-09 Event weight (ref) = 6.26874E-05 Event weight (prc) = 6.02689E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2566007711.0, 2240170159.0, 3022189282.0, 484554216.0, 1681294000.0, 1422185293.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3393932940.0, 2952039924.0, 1817149397.0, 3151505971.0, 2985798367.0, 2791898150.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 6.319084949E-11 +sqme_rad = 6.31908494XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487563E+05 P = 1.447377E+04 1.072132E+05 -2.239990E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383998E+05 P = -1.265869E+04 -1.014761E+05 2.153528E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.001283E+04 P = -1.661639E+03 -7.492873E+03 6.430601E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.831067E+03 P = -1.534389E+02 1.755770E+03 2.215551E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.174964E+05 P = -7.025912E+03 4.712115E+04 -2.122144E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.155529E+05 P = -1.119089E+04 -9.148298E+04 1.948555E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.163656E+04 P = -2.134855E+03 -6.459096E+03 9.440977E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.531409E+04 P = 2.035166E+04 5.082092E+04 7.917847E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.87907E-09 sqme_ref* => 2.99461E-09 event_index* => 2 event_weight* => 6.02689E-05 event_weight_ref* => 6.26874E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.4875629E+05; 1.4473772E+04, 1.0721317E+05,-2.2399897E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.3839981E+05;-1.2658694E+04,-1.0147606E+05, 2.1535282E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.0012832E+04;-1.6616390E+03,-7.4928729E+03, 6.4306006E+03| 0.0000000E+00| 5) - 6 prt(o:21| 2.8310666E+03;-1.5343894E+02, 1.7557702E+03, 2.2155509E+03| 0.0000000E+00| 6) + 5 prt(o:21| 1.001283XE+04;-1.661639XE+03,-7.492872XE+03, 6.430600XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 2.831066XE+03;-1.534389XE+02, 1.755770XE+03, 2.215550XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #2 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.99461E-09 Squared matrix el. (prc) = 5.23412E-11 Event weight (ref) = 6.26874E-05 Event weight (prc) = 1.09568E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2566007711.0, 2240170159.0, 3022189282.0, 484554216.0, 1681294000.0, 1422185293.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3393932940.0, 2952039924.0, 1817149397.0, 3151505971.0, 2985798367.0, 2791898150.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 6.319084949E-11 +sqme_rad = 6.31908494XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487563E+05 P = 1.447377E+04 1.072132E+05 -2.239990E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383998E+05 P = -1.265869E+04 -1.014761E+05 2.153528E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.001283E+04 P = -1.661639E+03 -7.492873E+03 6.430601E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.831067E+03 P = -1.534389E+02 1.755770E+03 2.215551E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.174964E+05 P = -7.025912E+03 4.712115E+04 -2.122144E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.155529E+05 P = -1.119089E+04 -9.148298E+04 1.948555E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.163656E+04 P = -2.134855E+03 -6.459096E+03 9.440977E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.531409E+04 P = 2.035166E+04 5.082092E+04 7.917847E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 5.23412E-11 sqme_ref* => 2.99461E-09 event_index* => 2 event_weight* => 1.09568E-06 event_weight_ref* => 6.26874E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.1749644E+05;-7.0259125E+03, 4.7121148E+04,-2.1221437E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.1555290E+05;-1.1190894E+04,-9.1482976E+04, 1.9485554E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.1636562E+04;-2.1348553E+03,-6.4590957E+03, 9.4409767E+03| 0.0000000E+00| 5) - 6 prt(o:21| 5.5314091E+04; 2.0351662E+04, 5.0820923E+04, 7.9178466E+03| 0.0000000E+00| 6) + 5 prt(o:21| 1.163656XE+04;-2.134855XE+03,-6.459095XE+03, 9.440976XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 5.531409XE+04; 2.035166XE+04, 5.082092XE+04, 7.917846XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #2 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.99461E-09 Squared matrix el. (prc) = 6.31908E-11 Event weight (ref) = 6.26874E-05 Event weight (prc) = 1.32280E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2566007711.0, 2240170159.0, 3022189282.0, 484554216.0, 1681294000.0, 1422185293.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3393932940.0, 2952039924.0, 1817149397.0, 3151505971.0, 2985798367.0, 2791898150.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 6.319084949E-11 +sqme_rad = 6.31908494XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498922E+05 P = 1.467270E+04 1.078419E+05 -2.249466E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.373179E+05 P = -1.246891E+04 -1.008762E+05 2.144488E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.278990E+04 P = -2.203788E+03 -6.965738E+03 1.049778E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487563E+05 P = 1.447377E+04 1.072132E+05 -2.239990E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383998E+05 P = -1.265869E+04 -1.014761E+05 2.153528E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.001283E+04 P = -1.661639E+03 -7.492873E+03 6.430601E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.831067E+03 P = -1.534389E+02 1.755770E+03 2.215551E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.174964E+05 P = -7.025912E+03 4.712115E+04 -2.122144E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.155529E+05 P = -1.119089E+04 -9.148298E+04 1.948555E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.163656E+04 P = -2.134855E+03 -6.459096E+03 9.440977E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.531409E+04 P = 2.035166E+04 5.082092E+04 7.917847E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.281457E+05 P = 1.353006E+04 9.859771E+04 -2.052946E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.053352E+05 P = -3.309403E+03 -1.298055E+05 1.590664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.398838E+04 P = -2.267795E+03 -7.483572E+03 1.159862E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 5.253073E+04 P = -7.952860E+03 3.869137E+04 3.462957E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 6.31908E-11 sqme_ref* => 2.99461E-09 event_index* => 2 event_weight* => 1.32280E-06 event_weight_ref* => 6.26874E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.2814568E+05; 1.3530057E+04, 9.8597709E+04,-2.0529462E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.0533521E+05;-3.3094026E+03,-1.2980551E+05, 1.5906642E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.3988379E+04;-2.2677952E+03,-7.4835722E+03, 1.1598621E+04| 0.0000000E+00| 5) - 6 prt(o:21| 5.2530730E+04;-7.9528596E+03, 3.8691371E+04, 3.4629575E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.398837XE+04;-2.267795XE+03,-7.483572XE+03, 1.159862XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 5.253073XE+04;-7.952859XE+03, 3.869137XE+04, 3.462957XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #3 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 5.35571E-11 Squared matrix el. (prc) = -1.05790E-03 Event weight (ref) = 4.09767E-11 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 658726814.0, 695277609.0, 1316830081.0, 2131992430.0, 749504030.0, 880099028.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1100463693.0, 3654384047.0, 647619641.0, 459938003.0, 1733458346.0, 3954010958.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.923323084E-11 +sqme_rad = 1.92332308XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499931E+05 P = 5.475338E+04 2.208098E+05 -1.036419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499948E+05 P = -5.474673E+04 -2.208104E+05 1.036482E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 1.003499E+01 P = -5.807919E+00 1.109636E+00 -8.107880E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 2.067649E+00 P = -8.361985E-01 -4.993300E-01 1.823900E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.378699E+05 P = 5.893797E+04 1.889232E+05 -1.319714E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.194078E+05 P = -4.804633E+04 -1.937939E+05 9.096849E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.249769E+01 P = -8.422184E+00 2.221758E+00 -8.962297E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.270971E+04 P = -1.088321E+04 4.868496E+03 4.101186E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => -1.05790E-03 sqme_ref* => 5.35571E-11 event_index* => 3 event_weight* => 0.00000E+00 event_weight_ref* => 4.09767E-11 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4999283E+05; 5.4754444E+04, 2.2080972E+05,-1.0364090E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4999506E+05;-5.4745670E+04,-2.2081052E+05, 1.0364920E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2102572E+01;-8.7732797E+00, 8.0588417E-01,-8.2977325E+00| 0.0000000E+00| 5) + 5 prt(o:21| 1.210257XE+01;-8.773279XE+00, 8.058841XE-01,-8.297732XE+00| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #3 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 5.35571E-11 Squared matrix el. (prc) = 4.00259E-04 Event weight (ref) = 4.09767E-11 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 658726814.0, 695277609.0, 1316830081.0, 2131992430.0, 749504030.0, 880099028.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1100463693.0, 3654384047.0, 647619641.0, 459938003.0, 1733458346.0, 3954010958.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.923323084E-11 +sqme_rad = 1.92332308XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499931E+05 P = 5.475338E+04 2.208098E+05 -1.036419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499948E+05 P = -5.474673E+04 -2.208104E+05 1.036482E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 1.003499E+01 P = -5.807919E+00 1.109636E+00 -8.107880E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 2.067649E+00 P = -8.361985E-01 -4.993300E-01 1.823900E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.378699E+05 P = 5.893797E+04 1.889232E+05 -1.319714E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.194078E+05 P = -4.804633E+04 -1.937939E+05 9.096849E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.249769E+01 P = -8.422184E+00 2.221758E+00 -8.962297E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.270971E+04 P = -1.088321E+04 4.868496E+03 4.101186E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 4.00259E-04 sqme_ref* => 5.35571E-11 event_index* => 3 event_weight* => 0.00000E+00 event_weight_ref* => 4.09767E-11 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4999310E+05; 5.4753379E+04, 2.2080982E+05,-1.0364191E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4999479E+05;-5.4746735E+04,-2.2081043E+05, 1.0364819E+05| 0.0000000E+00| 4) 5 prt(o:-2| 1.0034986E+01;-5.8079193E+00, 1.1096365E+00,-8.1078801E+00| 0.0000000E+00| 5) 6 prt(o:2| 2.0676487E+00;-8.3619846E-01,-4.9933002E-01, 1.8239005E+00| 0.0000000E+00| 6) ======================================================================== ======================================================================== Event #3 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 5.35571E-11 Squared matrix el. (prc) = 3.43239E-11 Event weight (ref) = 4.09767E-11 Event weight (prc) = 2.62613E-11 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 658726814.0, 695277609.0, 1316830081.0, 2131992430.0, 749504030.0, 880099028.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1100463693.0, 3654384047.0, 647619641.0, 459938003.0, 1733458346.0, 3954010958.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.923323084E-11 +sqme_rad = 1.92332308XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499931E+05 P = 5.475338E+04 2.208098E+05 -1.036419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499948E+05 P = -5.474673E+04 -2.208104E+05 1.036482E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 1.003499E+01 P = -5.807919E+00 1.109636E+00 -8.107880E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 2.067649E+00 P = -8.361985E-01 -4.993300E-01 1.823900E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.378699E+05 P = 5.893797E+04 1.889232E+05 -1.319714E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.194078E+05 P = -4.804633E+04 -1.937939E+05 9.096849E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.249769E+01 P = -8.422184E+00 2.221758E+00 -8.962297E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.270971E+04 P = -1.088321E+04 4.868496E+03 4.101186E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.43239E-11 sqme_ref* => 5.35571E-11 event_index* => 3 event_weight* => 2.62613E-11 event_weight_ref* => 4.09767E-11 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.3786995E+05; 5.8937970E+04, 1.8892321E+05,-1.3197139E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.1940785E+05;-4.8046334E+04,-1.9379393E+05, 9.0968487E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.2497686E+01;-8.4221839E+00, 2.2217578E+00,-8.9622975E+00| 0.0000000E+00| 5) - 6 prt(o:21| 4.2709712E+04;-1.0883214E+04, 4.8684964E+03, 4.1011862E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.249768XE+01;-8.422183XE+00, 2.221757XE+00,-8.962297XE+00| 0.000000XE+00| 5) + 6 prt(o:21| 4.270971XE+04;-1.088321XE+04, 4.868496XE+03, 4.101186XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #3 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 5.35571E-11 Squared matrix el. (prc) = 1.92332E-11 Event weight (ref) = 4.09767E-11 Event weight (prc) = 1.47154E-11 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 658726814.0, 695277609.0, 1316830081.0, 2131992430.0, 749504030.0, 880099028.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1100463693.0, 3654384047.0, 647619641.0, 459938003.0, 1733458346.0, 3954010958.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.923323084E-11 +sqme_rad = 1.92332308XE-11 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499928E+05 P = 5.475444E+04 2.208097E+05 -1.036409E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499951E+05 P = -5.474567E+04 -2.208105E+05 1.036492E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.210257E+01 P = -8.773280E+00 8.058842E-01 -8.297732E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499931E+05 P = 5.475338E+04 2.208098E+05 -1.036419E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.499948E+05 P = -5.474673E+04 -2.208104E+05 1.036482E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 1.003499E+01 P = -5.807919E+00 1.109636E+00 -8.107880E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 2.067649E+00 P = -8.361985E-01 -4.993300E-01 1.823900E+00 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.378699E+05 P = 5.893797E+04 1.889232E+05 -1.319714E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.194078E+05 P = -4.804633E+04 -1.937939E+05 9.096849E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.249769E+01 P = -8.422184E+00 2.221758E+00 -8.962297E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.270971E+04 P = -1.088321E+04 4.868496E+03 4.101186E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.194056E+05 P = 4.805624E+04 1.937933E+05 -9.095929E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.378724E+05 P = -6.655189E+04 -2.196641E+05 6.246438E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.191381E+01 P = -9.115988E+00 -5.763905E-01 -7.648888E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 4.271009E+04 P = 1.850477E+04 2.587141E+04 2.850256E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.92332E-11 sqme_ref* => 5.35571E-11 event_index* => 3 event_weight* => 1.47154E-11 event_weight_ref* => 4.09767E-11 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.1940561E+05; 4.8056240E+04, 1.9379326E+05,-9.0959286E+04| 0.0000000E+00| 3) 4 prt(o:2| 2.3787238E+05;-6.6551890E+04,-2.1966410E+05, 6.2464380E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.1913813E+01;-9.1159878E+00,-5.7639049E-01,-7.6488881E+00| 0.0000000E+00| 5) - 6 prt(o:21| 4.2710093E+04; 1.8504766E+04, 2.5871413E+04, 2.8502555E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.191381XE+01;-9.115987XE+00,-5.763904XE-01,-7.648888XE+00| 0.000000XE+00| 5) + 6 prt(o:21| 4.271009XE+04; 1.850476XE+04, 2.587141XE+04, 2.850255XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #4 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.11517E-10 Squared matrix el. (prc) = -4.20084E-09 Event weight (ref) = 2.67265E-07 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 852933358.0, 3802412940.0, 3514872455.0, 1024477926.0, 3849273974.0, 775318609.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 598672993.0, 229519251.0, 2192350721.0, 2167080660.0, 1984333633.0, 1125498793.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.057479501E-12 +sqme_rad = 2.05747950XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.402098E+05 P = -9.916913E+04 -1.776598E+05 -1.276842E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.470398E+05 P = 1.040861E+05 1.818731E+05 1.308317E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 5.196862E+03 P = -1.974904E+03 -3.054029E+03 3.712147E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 7.553455E+03 P = -2.942054E+03 -1.159324E+03 -6.859662E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.595906E+05 P = -4.904747E+04 -1.427702E+05 5.177032E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.811710E+05 P = 7.791726E+04 1.327318E+05 9.557250E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.719717E+04 P = -1.057542E+04 -1.091231E+04 -8.051372E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.420413E+05 P = -1.829437E+04 2.095069E+04 -1.392914E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => -4.20084E-09 sqme_ref* => 2.11517E-10 event_index* => 4 event_weight* => 0.00000E+00 event_weight_ref* => 2.67265E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.3768493E+05;-9.7347450E+04,-1.7609878E+05,-1.2651805E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4967549E+05; 1.0597952E+05, 1.8349562E+05, 1.3204374E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2639582E+04;-8.6320673E+03,-7.3968406E+03,-5.5256857E+03| 0.0000000E+00| 5) + 5 prt(o:21| 1.263958XE+04;-8.632067XE+03,-7.396840XE+03,-5.525685XE+03| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #4 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.11517E-10 Squared matrix el. (prc) = 2.07646E-10 Event weight (ref) = 2.67265E-07 Event weight (prc) = 2.62373E-07 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 852933358.0, 3802412940.0, 3514872455.0, 1024477926.0, 3849273974.0, 775318609.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 598672993.0, 229519251.0, 2192350721.0, 2167080660.0, 1984333633.0, 1125498793.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.057479501E-12 +sqme_rad = 2.05747950XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.402098E+05 P = -9.916913E+04 -1.776598E+05 -1.276842E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.470398E+05 P = 1.040861E+05 1.818731E+05 1.308317E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 5.196862E+03 P = -1.974904E+03 -3.054029E+03 3.712147E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 7.553455E+03 P = -2.942054E+03 -1.159324E+03 -6.859662E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.595906E+05 P = -4.904747E+04 -1.427702E+05 5.177032E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.811710E+05 P = 7.791726E+04 1.327318E+05 9.557250E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.719717E+04 P = -1.057542E+04 -1.091231E+04 -8.051372E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.420413E+05 P = -1.829437E+04 2.095069E+04 -1.392914E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.07646E-10 sqme_ref* => 2.11517E-10 event_index* => 4 event_weight* => 2.62373E-07 event_weight_ref* => 2.67265E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-3| 2.4020984E+05;-9.9169134E+04,-1.7765979E+05,-1.2768418E+05| 0.0000000E+00| 3) 4 prt(o:3| 2.4703985E+05; 1.0408609E+05, 1.8187314E+05, 1.3083169E+05| 0.0000000E+00| 4) - 5 prt(o:21| 5.1968624E+03;-1.9749038E+03,-3.0540295E+03, 3.7121473E+03| 0.0000000E+00| 5) - 6 prt(o:21| 7.5534548E+03;-2.9420537E+03,-1.1593240E+03,-6.8596623E+03| 0.0000000E+00| 6) + 5 prt(o:21| 5.196862XE+03;-1.974903XE+03,-3.054029XE+03, 3.712147XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 7.553454XE+03;-2.942053XE+03,-1.159324XE+03,-6.859662XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #4 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.11517E-10 Squared matrix el. (prc) = 1.81416E-12 Event weight (ref) = 2.67265E-07 Event weight (prc) = 2.29231E-09 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 852933358.0, 3802412940.0, 3514872455.0, 1024477926.0, 3849273974.0, 775318609.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 598672993.0, 229519251.0, 2192350721.0, 2167080660.0, 1984333633.0, 1125498793.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.057479501E-12 +sqme_rad = 2.05747950XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.402098E+05 P = -9.916913E+04 -1.776598E+05 -1.276842E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.470398E+05 P = 1.040861E+05 1.818731E+05 1.308317E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 5.196862E+03 P = -1.974904E+03 -3.054029E+03 3.712147E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 7.553455E+03 P = -2.942054E+03 -1.159324E+03 -6.859662E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.595906E+05 P = -4.904747E+04 -1.427702E+05 5.177032E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.811710E+05 P = 7.791726E+04 1.327318E+05 9.557250E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.719717E+04 P = -1.057542E+04 -1.091231E+04 -8.051372E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.420413E+05 P = -1.829437E+04 2.095069E+04 -1.392914E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.81416E-12 sqme_ref* => 2.11517E-10 event_index* => 4 event_weight* => 2.29231E-09 event_weight_ref* => 2.67265E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.5959055E+05;-4.9047475E+04,-1.4277018E+05, 5.1770318E+04| 0.0000000E+00| 3) 4 prt(o:2| 1.8117101E+05; 7.7917264E+04, 1.3273180E+05, 9.5572504E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.7197168E+04;-1.0575419E+04,-1.0912310E+04,-8.0513721E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.4204127E+05;-1.8294370E+04, 2.0950687E+04,-1.3929145E+05| 0.0000000E+00| 6) + 5 prt(o:21| 1.719716XE+04;-1.057541XE+04,-1.091231XE+04,-8.051372XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.420412XE+05;-1.829437XE+04, 2.095068XE+04,-1.392914XE+05| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #4 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 2.11517E-10 Squared matrix el. (prc) = 2.05748E-12 Event weight (ref) = 2.67265E-07 Event weight (prc) = 2.59975E-09 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 852933358.0, 3802412940.0, 3514872455.0, 1024477926.0, 3849273974.0, 775318609.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 598672993.0, 229519251.0, 2192350721.0, 2167080660.0, 1984333633.0, 1125498793.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 2.057479501E-12 +sqme_rad = 2.05747950XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.376849E+05 P = -9.734745E+04 -1.760988E+05 -1.265181E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.496755E+05 P = 1.059795E+05 1.834956E+05 1.320437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.263958E+04 P = -8.632067E+03 -7.396841E+03 -5.525686E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.402098E+05 P = -9.916913E+04 -1.776598E+05 -1.276842E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.470398E+05 P = 1.040861E+05 1.818731E+05 1.308317E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 5.196862E+03 P = -1.974904E+03 -3.054029E+03 3.712147E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 7.553455E+03 P = -2.942054E+03 -1.159324E+03 -6.859662E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.595906E+05 P = -4.904747E+04 -1.427702E+05 5.177032E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.811710E+05 P = 7.791726E+04 1.327318E+05 9.557250E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.719717E+04 P = -1.057542E+04 -1.091231E+04 -8.051372E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.420413E+05 P = -1.829437E+04 2.095069E+04 -1.392914E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 1.681412E+05 P = -6.782269E+04 -1.249789E+05 -8.973208E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 1.734932E+05 P = -1.186191E+04 3.511476E+04 1.694879E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.158701E+03 P = -7.046193E+03 -4.651018E+03 -3.549788E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.492069E+05 P = 8.673079E+04 9.451512E+04 -7.620600E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.05748E-12 sqme_ref* => 2.11517E-10 event_index* => 4 event_weight* => 2.59975E-09 event_weight_ref* => 2.67265E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-3| 1.6814124E+05;-6.7822687E+04,-1.2497886E+05,-8.9732076E+04| 0.0000000E+00| 3) 4 prt(o:3| 1.7349319E+05;-1.1861907E+04, 3.5114759E+04, 1.6948786E+05| 0.0000000E+00| 4) - 5 prt(o:21| 9.1587010E+03;-7.0461933E+03,-4.6510183E+03,-3.5497876E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.4920687E+05; 8.6730787E+04, 9.4515117E+04,-7.6205995E+04| 0.0000000E+00| 6) + 5 prt(o:21| 9.158701XE+03;-7.046193XE+03,-4.651018XE+03,-3.549787XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.492068XE+05; 8.673078XE+04, 9.451511XE+04,-7.620599XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #5 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 9.37951E-07 Squared matrix el. (prc) = 7.86870E-07 Event weight (ref) = 6.19701E-04 Event weight (prc) = 5.19882E-04 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 1 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1095625977.0, 443063532.0, 2957163220.0, 222499157.0, 3835620558.0, 2328100909.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1106982763.0, 4232153153.0, 2882700880.0, 3746330306.0, 161521528.0, 2991739543.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906258E-12 +sqme_rad = 3.84890625XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.497695E+05 P = -3.002715E+04 1.512306E+05 -1.965005E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.490052E+05 P = 2.961243E+04 -1.507153E+05 1.959887E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.826715E+02 P = 3.602545E+02 1.245413E+02 -3.381796E+01 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.426673E+02 P = 5.446535E+01 -6.398884E+02 5.455864E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.362137E+05 P = -1.144984E+05 -7.433487E+03 -7.340993E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.908174E+05 P = 2.252490E+04 -1.154686E+05 1.502362E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.672594E+02 P = 5.723541E+02 -5.794190E+02 5.218000E+02 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.720017E+05 P = 9.140118E+04 1.234815E+05 -7.734808E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 7.86870E-07 sqme_ref* => 9.37951E-07 event_index* => 5 event_weight* => 5.19882E-04 event_weight_ref* => 6.19701E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4994724E+05;-3.0123578E+04, 1.5135046E+05,-1.9661951E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4882822E+05; 2.9516369E+04,-1.5059592E+05, 1.9587020E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2245368E+03; 6.0720914E+02,-7.5454193E+02, 7.4930231E+02| 0.0000000E+00| 5) + 5 prt(o:21| 1.224536XE+03; 6.072091XE+02,-7.545419XE+02, 7.493023XE+02| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #5 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 9.37951E-07 Squared matrix el. (prc) = 1.51075E-07 Event weight (ref) = 6.19701E-04 Event weight (prc) = 9.98147E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 1 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1095625977.0, 443063532.0, 2957163220.0, 222499157.0, 3835620558.0, 2328100909.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1106982763.0, 4232153153.0, 2882700880.0, 3746330306.0, 161521528.0, 2991739543.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906258E-12 +sqme_rad = 3.84890625XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.497695E+05 P = -3.002715E+04 1.512306E+05 -1.965005E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.490052E+05 P = 2.961243E+04 -1.507153E+05 1.959887E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.826715E+02 P = 3.602545E+02 1.245413E+02 -3.381796E+01 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.426673E+02 P = 5.446535E+01 -6.398884E+02 5.455864E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.362137E+05 P = -1.144984E+05 -7.433487E+03 -7.340993E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.908174E+05 P = 2.252490E+04 -1.154686E+05 1.502362E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.672594E+02 P = 5.723541E+02 -5.794190E+02 5.218000E+02 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.720017E+05 P = 9.140118E+04 1.234815E+05 -7.734808E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.51075E-07 sqme_ref* => 9.37951E-07 event_index* => 5 event_weight* => 9.98147E-05 event_weight_ref* => 6.19701E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-3| 2.4976947E+05;-3.0027152E+04, 1.5123064E+05,-1.9650052E+05| 0.0000000E+00| 3) 4 prt(o:3| 2.4900519E+05; 2.9612432E+04,-1.5071529E+05, 1.9598875E+05| 0.0000000E+00| 4) - 5 prt(o:21| 3.8267147E+02; 3.6025445E+02, 1.2454128E+02,-3.3817956E+01| 0.0000000E+00| 5) - 6 prt(o:21| 8.4266732E+02; 5.4465352E+01,-6.3988840E+02, 5.4558645E+02| 0.0000000E+00| 6) + 5 prt(o:21| 3.826714XE+02; 3.602544XE+02, 1.245412XE+02,-3.381795XE+01| 0.000000XE+00| 5) + 6 prt(o:21| 8.426673XE+02; 5.446535XE+01,-6.398884XE+02, 5.455864XE+02| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #5 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 9.37951E-07 Squared matrix el. (prc) = 2.69142E-12 Event weight (ref) = 6.19701E-04 Event weight (prc) = 1.77821E-09 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 1 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1095625977.0, 443063532.0, 2957163220.0, 222499157.0, 3835620558.0, 2328100909.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1106982763.0, 4232153153.0, 2882700880.0, 3746330306.0, 161521528.0, 2991739543.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906258E-12 +sqme_rad = 3.84890625XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.497695E+05 P = -3.002715E+04 1.512306E+05 -1.965005E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.490052E+05 P = 2.961243E+04 -1.507153E+05 1.959887E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.826715E+02 P = 3.602545E+02 1.245413E+02 -3.381796E+01 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.426673E+02 P = 5.446535E+01 -6.398884E+02 5.455864E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.362137E+05 P = -1.144984E+05 -7.433487E+03 -7.340993E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.908174E+05 P = 2.252490E+04 -1.154686E+05 1.502362E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.672594E+02 P = 5.723541E+02 -5.794190E+02 5.218000E+02 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.720017E+05 P = 9.140118E+04 1.234815E+05 -7.734808E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.69142E-12 sqme_ref* => 9.37951E-07 event_index* => 5 event_weight* => 1.77821E-09 event_weight_ref* => 6.19701E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 1.3621368E+05;-1.1449843E+05,-7.4334869E+03,-7.3409933E+04| 0.0000000E+00| 3) 4 prt(o:1| 1.9081740E+05; 2.2524901E+04,-1.1546856E+05, 1.5023622E+05| 0.0000000E+00| 4) - 5 prt(o:21| 9.6725942E+02; 5.7235408E+02,-5.7941900E+02, 5.2179998E+02| 0.0000000E+00| 5) - 6 prt(o:21| 1.7200166E+05; 9.1401178E+04, 1.2348146E+05,-7.7348083E+04| 0.0000000E+00| 6) + 5 prt(o:21| 9.672594XE+02; 5.723540XE+02,-5.794190XE+02, 5.217999XE+02| 0.000000XE+00| 5) + 6 prt(o:21| 1.720016XE+05; 9.140117XE+04, 1.234814XE+05,-7.734808XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #5 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 9.37951E-07 Squared matrix el. (prc) = 3.84891E-12 Event weight (ref) = 6.19701E-04 Event weight (prc) = 2.54296E-09 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 1 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1095625977.0, 443063532.0, 2957163220.0, 222499157.0, 3835620558.0, 2328100909.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1106982763.0, 4232153153.0, 2882700880.0, 3746330306.0, 161521528.0, 2991739543.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906258E-12 +sqme_rad = 3.84890625XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499472E+05 P = -3.012358E+04 1.513505E+05 -1.966195E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.488282E+05 P = 2.951637E+04 -1.505959E+05 1.958702E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.224537E+03 P = 6.072091E+02 -7.545419E+02 7.493023E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.497695E+05 P = -3.002715E+04 1.512306E+05 -1.965005E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.490052E+05 P = 2.961243E+04 -1.507153E+05 1.959887E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.826715E+02 P = 3.602545E+02 1.245413E+02 -3.381796E+01 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 8.426673E+02 P = 5.446535E+01 -6.398884E+02 5.455864E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.362137E+05 P = -1.144984E+05 -7.433487E+03 -7.340993E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.908174E+05 P = 2.252490E+04 -1.154686E+05 1.502362E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 9.672594E+02 P = 5.723541E+02 -5.794190E+02 5.218000E+02 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.720017E+05 P = 9.140118E+04 1.234815E+05 -7.734808E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.920514E+05 P = -2.325588E+04 1.163106E+05 -1.510455E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.351515E+05 P = 1.237788E+05 -4.406957E+04 3.166401E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.565428E+03 P = 6.505592E+02 -9.757187E+02 1.036972E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.712316E+05 P = -1.011735E+05 -7.126537E+04 1.183445E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.84891E-12 sqme_ref* => 9.37951E-07 event_index* => 5 event_weight* => 2.54296E-09 event_weight_ref* => 6.19701E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.9205144E+05;-2.3255875E+04, 1.1631065E+05,-1.5104553E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.3515152E+05; 1.2377883E+05,-4.4069566E+04, 3.1664006E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.5654284E+03; 6.5055916E+02,-9.7571875E+02, 1.0369724E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.7123161E+05;-1.0117351E+05,-7.1265365E+04, 1.1834455E+05| 0.0000000E+00| 6) + 5 prt(o:21| 1.565428XE+03; 6.505591XE+02,-9.757187XE+02, 1.036972XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.712316XE+05;-1.011735XE+05,-7.126536XE+04, 1.183445XE+05| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #6 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 0.00000E+00 Squared matrix el. (prc) = 0.00000E+00 Event weight (ref) = 0.00000E+00 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2643453732.0, 343801519.0, 3374377404.0, 2585822891.0, 2834629654.0, 677007669.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2714720639.0, 1946415819.0, 2496115977.0, 2267707328.0, 4192754391.0, 3326698294.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906258E-12 +sqme_rad = 3.84890625XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499853E+05 P = 1.706024E+03 5.494993E+04 -2.438652E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754291E+05 P = -1.752218E+03 -3.869184E+04 1.711001E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 3.061428E+04 P = 6.524800E+02 -5.947974E+03 3.002382E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 4.397135E+04 P = -6.062864E+02 -1.031012E+04 4.274124E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.026503E+05 P = -1.354547E+03 2.503842E+04 -9.954061E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.753888E+05 P = -1.752012E+03 -3.868300E+04 1.710608E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.456851E+04 P = 4.629753E+01 -1.626009E+04 7.277410E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.473923E+05 P = 3.060261E+03 2.990467E+04 -1.442943E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 0.00000E+00 sqme_ref* => 0.00000E+00 event_index* => 6 event_weight* => 0.00000E+00 event_weight_ref* => 0.00000E+00 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4999844E+05; 1.7060160E+03, 5.4952809E+04,-2.4387804E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.7541986E+05;-1.7522235E+03,-3.8689819E+04, 1.7109108E+05| 0.0000000E+00| 4) - 5 prt(o:21| 7.4581696E+04; 4.6207513E+01,-1.6262989E+04, 7.2786966E+04| 0.0000000E+00| 5) + 5 prt(o:21| 7.458169XE+04; 4.620751XE+01,-1.626298XE+04, 7.278696XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #6 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 0.00000E+00 Squared matrix el. (prc) = 0.00000E+00 Event weight (ref) = 0.00000E+00 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2643453732.0, 343801519.0, 3374377404.0, 2585822891.0, 2834629654.0, 677007669.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2714720639.0, 1946415819.0, 2496115977.0, 2267707328.0, 4192754391.0, 3326698294.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906258E-12 +sqme_rad = 3.84890625XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499853E+05 P = 1.706024E+03 5.494993E+04 -2.438652E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754291E+05 P = -1.752218E+03 -3.869184E+04 1.711001E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 3.061428E+04 P = 6.524800E+02 -5.947974E+03 3.002382E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 4.397135E+04 P = -6.062864E+02 -1.031012E+04 4.274124E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.026503E+05 P = -1.354547E+03 2.503842E+04 -9.954061E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.753888E+05 P = -1.752012E+03 -3.868300E+04 1.710608E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.456851E+04 P = 4.629753E+01 -1.626009E+04 7.277410E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.473923E+05 P = 3.060261E+03 2.990467E+04 -1.442943E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 0.00000E+00 sqme_ref* => 0.00000E+00 event_index* => 6 event_weight* => 0.00000E+00 event_weight_ref* => 0.00000E+00 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4998525E+05; 1.7060241E+03, 5.4949933E+04,-2.4386517E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.7542912E+05;-1.7522177E+03,-3.8691837E+04, 1.7110011E+05| 0.0000000E+00| 4) 5 prt(o:-2| 3.0614277E+04; 6.5247997E+02,-5.9479744E+03, 3.0023821E+04| 0.0000000E+00| 5) 6 prt(o:2| 4.3971353E+04;-6.0628636E+02,-1.0310121E+04, 4.2741241E+04| 0.0000000E+00| 6) ======================================================================== ======================================================================== Event #6 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 0.00000E+00 Squared matrix el. (prc) = 0.00000E+00 Event weight (ref) = 0.00000E+00 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2643453732.0, 343801519.0, 3374377404.0, 2585822891.0, 2834629654.0, 677007669.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2714720639.0, 1946415819.0, 2496115977.0, 2267707328.0, 4192754391.0, 3326698294.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906258E-12 +sqme_rad = 3.84890625XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499853E+05 P = 1.706024E+03 5.494993E+04 -2.438652E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754291E+05 P = -1.752218E+03 -3.869184E+04 1.711001E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 3.061428E+04 P = 6.524800E+02 -5.947974E+03 3.002382E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 4.397135E+04 P = -6.062864E+02 -1.031012E+04 4.274124E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.026503E+05 P = -1.354547E+03 2.503842E+04 -9.954061E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.753888E+05 P = -1.752012E+03 -3.868300E+04 1.710608E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.456851E+04 P = 4.629753E+01 -1.626009E+04 7.277410E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.473923E+05 P = 3.060261E+03 2.990467E+04 -1.442943E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 0.00000E+00 sqme_ref* => 0.00000E+00 event_index* => 6 event_weight* => 0.00000E+00 event_weight_ref* => 0.00000E+00 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.0265033E+05;-1.3545472E+03, 2.5038418E+04,-9.9540612E+04| 0.0000000E+00| 3) 4 prt(o:2| 1.7538884E+05;-1.7520118E+03,-3.8682999E+04, 1.7106081E+05| 0.0000000E+00| 4) 5 prt(o:-2| 7.4568505E+04; 4.6297531E+01,-1.6260090E+04, 7.2774098E+04| 0.0000000E+00| 5) 6 prt(o:2| 1.4739233E+05; 3.0602614E+03, 2.9904671E+04,-1.4429429E+05| 0.0000000E+00| 6) ======================================================================== ======================================================================== Event #6 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 0.00000E+00 Squared matrix el. (prc) = 0.00000E+00 Event weight (ref) = 0.00000E+00 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2643453732.0, 343801519.0, 3374377404.0, 2585822891.0, 2834629654.0, 677007669.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2714720639.0, 1946415819.0, 2496115977.0, 2267707328.0, 4192754391.0, 3326698294.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 3.848906258E-12 +sqme_rad = 3.84890625XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499984E+05 P = 1.706016E+03 5.495281E+04 -2.438780E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754199E+05 P = -1.752223E+03 -3.868982E+04 1.710911E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 7.458170E+04 P = 4.620751E+01 -1.626299E+04 7.278697E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499853E+05 P = 1.706024E+03 5.494993E+04 -2.438652E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.754291E+05 P = -1.752218E+03 -3.869184E+04 1.711001E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 3.061428E+04 P = 6.524800E+02 -5.947974E+03 3.002382E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 4.397135E+04 P = -6.062864E+02 -1.031012E+04 4.274124E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.026503E+05 P = -1.354547E+03 2.503842E+04 -9.954061E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.753888E+05 P = -1.752012E+03 -3.868300E+04 1.710608E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.456851E+04 P = 4.629753E+01 -1.626009E+04 7.277410E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.473923E+05 P = 3.060261E+03 2.990467E+04 -1.442943E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.499674E+05 P = 1.705706E+03 5.494597E+04 -2.438478E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 7.201882E+04 P = 8.513592E+02 -1.424709E+04 7.059041E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(-2) E = 7.459095E+04 P = 4.611505E+01 -1.626503E+04 7.279599E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(2) E = 1.034228E+05 P = -2.603180E+03 -2.443384E+04 1.004614E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 0.00000E+00 sqme_ref* => 0.00000E+00 event_index* => 6 event_weight* => 0.00000E+00 event_weight_ref* => 0.00000E+00 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4996742E+05; 1.7057061E+03, 5.4945966E+04,-2.4384778E+05| 0.0000000E+00| 3) 4 prt(o:2| 7.2018820E+04; 8.5135922E+02,-1.4247092E+04, 7.0590410E+04| 0.0000000E+00| 4) 5 prt(o:-2| 7.4590952E+04; 4.6115053E+01,-1.6265031E+04, 7.2795994E+04| 0.0000000E+00| 5) 6 prt(o:2| 1.0342281E+05;-2.6031803E+03,-2.4433843E+04, 1.0046138E+05| 0.0000000E+00| 6) ======================================================================== ======================================================================== Event #7 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 8.55503E-11 Squared matrix el. (prc) = 3.55893E-11 Event weight (ref) = 7.63602E-07 Event weight (prc) = 3.17662E-07 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2042523454.0, 1790911384.0, 3715479539.0, 3582083863.0, 2240445629.0, 3470253870.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3203562530.0, 370100846.0, 1647107524.0, 1466280485.0, 4189984473.0, 360074395.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.501742439E-12 +sqme_rad = 1.50174243XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.244498E+05 P = 2.194884E+04 7.093818E+04 -2.118106E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.339690E+05 P = -3.866983E+04 -7.103777E+04 2.195445E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.909056E+04 P = 1.211138E+04 6.048845E+03 1.346014E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.249061E+04 P = 4.609609E+03 -5.949262E+03 -2.119400E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.604817E+05 P = -1.425889E+04 1.471368E+05 -6.246461E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.668286E+05 P = -4.465765E+04 -4.698808E+04 1.537192E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.984911E+04 P = 3.741068E+04 5.549687E+03 -3.247423E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.228405E+05 P = 2.150586E+04 -1.056984E+05 -5.878040E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.55893E-11 sqme_ref* => 8.55503E-11 event_index* => 7 event_weight* => 3.17662E-07 event_weight_ref* => 7.63602E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.1952077E+05; 1.2396103E+04, 7.0881292E+04,-2.0739226E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4028763E+05;-4.8874220E+04,-7.1098540E+04, 2.2426425E+05| 0.0000000E+00| 4) - 5 prt(o:21| 4.0191596E+04; 3.6478117E+04, 2.1724804E+02,-1.6871992E+04| 0.0000000E+00| 5) + 5 prt(o:21| 4.019159XE+04; 3.647811XE+04, 2.172480XE+02,-1.687199XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #7 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 8.55503E-11 Squared matrix el. (prc) = 4.70453E-11 Event weight (ref) = 7.63602E-07 Event weight (prc) = 4.19915E-07 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2042523454.0, 1790911384.0, 3715479539.0, 3582083863.0, 2240445629.0, 3470253870.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3203562530.0, 370100846.0, 1647107524.0, 1466280485.0, 4189984473.0, 360074395.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.501742439E-12 +sqme_rad = 1.50174243XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.244498E+05 P = 2.194884E+04 7.093818E+04 -2.118106E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.339690E+05 P = -3.866983E+04 -7.103777E+04 2.195445E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.909056E+04 P = 1.211138E+04 6.048845E+03 1.346014E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.249061E+04 P = 4.609609E+03 -5.949262E+03 -2.119400E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.604817E+05 P = -1.425889E+04 1.471368E+05 -6.246461E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.668286E+05 P = -4.465765E+04 -4.698808E+04 1.537192E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.984911E+04 P = 3.741068E+04 5.549687E+03 -3.247423E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.228405E+05 P = 2.150586E+04 -1.056984E+05 -5.878040E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 4.70453E-11 sqme_ref* => 8.55503E-11 event_index* => 7 event_weight* => 4.19915E-07 event_weight_ref* => 7.63602E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-3| 2.2444981E+05; 2.1948838E+04, 7.0938184E+04,-2.1181062E+05| 0.0000000E+00| 3) 4 prt(o:3| 2.3396901E+05;-3.8669832E+04,-7.1037767E+04, 2.1954448E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.9090562E+04; 1.2111384E+04, 6.0488448E+03, 1.3460141E+04| 0.0000000E+00| 5) - 6 prt(o:21| 2.2490614E+04; 4.6096094E+03,-5.9492617E+03,-2.1193996E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.909056XE+04; 1.211138XE+04, 6.048844XE+03, 1.346014XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 2.249061XE+04; 4.609609XE+03,-5.949261XE+03,-2.119399XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #7 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 8.55503E-11 Squared matrix el. (prc) = 1.41404E-12 Event weight (ref) = 7.63602E-07 Event weight (prc) = 1.26214E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2042523454.0, 1790911384.0, 3715479539.0, 3582083863.0, 2240445629.0, 3470253870.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3203562530.0, 370100846.0, 1647107524.0, 1466280485.0, 4189984473.0, 360074395.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.501742439E-12 +sqme_rad = 1.50174243XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.244498E+05 P = 2.194884E+04 7.093818E+04 -2.118106E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.339690E+05 P = -3.866983E+04 -7.103777E+04 2.195445E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.909056E+04 P = 1.211138E+04 6.048845E+03 1.346014E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.249061E+04 P = 4.609609E+03 -5.949262E+03 -2.119400E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.604817E+05 P = -1.425889E+04 1.471368E+05 -6.246461E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.668286E+05 P = -4.465765E+04 -4.698808E+04 1.537192E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.984911E+04 P = 3.741068E+04 5.549687E+03 -3.247423E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.228405E+05 P = 2.150586E+04 -1.056984E+05 -5.878040E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.41404E-12 sqme_ref* => 8.55503E-11 event_index* => 7 event_weight* => 1.26214E-08 event_weight_ref* => 7.63602E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 1.6048174E+05;-1.4258890E+04, 1.4713683E+05,-6.2464608E+04| 0.0000000E+00| 3) 4 prt(o:1| 1.6682862E+05;-4.4657654E+04,-4.6988084E+04, 1.5371923E+05| 0.0000000E+00| 4) - 5 prt(o:21| 4.9849108E+04; 3.7410683E+04, 5.5496867E+03,-3.2474226E+04| 0.0000000E+00| 5) - 6 prt(o:21| 1.2284053E+05; 2.1505860E+04,-1.0569843E+05,-5.8780399E+04| 0.0000000E+00| 6) + 5 prt(o:21| 4.984910XE+04; 3.741068XE+04, 5.549686XE+03,-3.247422XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 1.228405XE+05; 2.150586XE+04,-1.056984XE+05,-5.878039XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #7 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 8.55503E-11 Squared matrix el. (prc) = 1.50174E-12 Event weight (ref) = 7.63602E-07 Event weight (prc) = 1.34042E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2042523454.0, 1790911384.0, 3715479539.0, 3582083863.0, 2240445629.0, 3470253870.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3203562530.0, 370100846.0, 1647107524.0, 1466280485.0, 4189984473.0, 360074395.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.501742439E-12 +sqme_rad = 1.50174243XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.195208E+05 P = 1.239610E+04 7.088129E+04 -2.073923E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.402876E+05 P = -4.887422E+04 -7.109854E+04 2.242643E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.019160E+04 P = 3.647812E+04 2.172480E+02 -1.687199E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-3) E = 2.244498E+05 P = 2.194884E+04 7.093818E+04 -2.118106E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(3) E = 2.339690E+05 P = -3.866983E+04 -7.103777E+04 2.195445E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.909056E+04 P = 1.211138E+04 6.048845E+03 1.346014E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.249061E+04 P = 4.609609E+03 -5.949262E+03 -2.119400E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.604817E+05 P = -1.425889E+04 1.471368E+05 -6.246461E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 1.668286E+05 P = -4.465765E+04 -4.698808E+04 1.537192E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 4.984911E+04 P = 3.741068E+04 5.549687E+03 -3.247423E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.228405E+05 P = 2.150586E+04 -1.056984E+05 -5.878040E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 1.444813E+05 P = -3.132862E+03 4.829092E+04 -1.361361E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.873602E+05 P = 7.577496E+04 3.340176E+04 1.680664E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 3.369711E+04 P = 3.332590E+04 -4.368366E+03 -2.407710E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.344614E+05 P = -1.059680E+05 -7.732432E+04 -2.952268E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.50174E-12 sqme_ref* => 8.55503E-11 event_index* => 7 event_weight* => 1.34042E-08 event_weight_ref* => 7.63602E-07 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 1.4448132E+05;-3.1328617E+03, 4.8290923E+04,-1.3613605E+05| 0.0000000E+00| 3) 4 prt(o:2| 1.8736022E+05; 7.5774962E+04, 3.3401761E+04, 1.6806644E+05| 0.0000000E+00| 4) - 5 prt(o:21| 3.3697108E+04; 3.3325896E+04,-4.3683660E+03,-2.4077104E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.3446135E+05;-1.0596800E+05,-7.7324317E+04,-2.9522682E+04| 0.0000000E+00| 6) + 5 prt(o:21| 3.369710XE+04; 3.332589XE+04,-4.368366XE+03,-2.407710XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.344613XE+05;-1.059680XE+05,-7.732431XE+04,-2.952268XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #8 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.79521E-07 Squared matrix el. (prc) = 1.56951E-07 Event weight (ref) = 1.57909E-05 Event weight (prc) = 1.38056E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3361222980.0, 3601284.0, 3842382860.0, 2580515999.0, 3568184670.0, 735623006.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2280904955.0, 1539004561.0, 852756080.0, 3258303332.0, 2415368508.0, 1295976056.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 4.950788936E-12 +sqme_rad = 4.95078893XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.497882E+05 P = 2.527464E+04 5.385094E+04 -2.426014E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.481274E+05 P = -2.453238E+04 -5.336726E+04 2.410754E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.027923E+02 P = 1.805539E+02 9.186084E+01 -9.305294E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.881521E+03 P = -9.228099E+02 -5.755396E+02 1.535349E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 8.895887E+04 P = 2.293156E+04 7.424874E+04 4.330067E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.837066E+05 P = -1.794896E+04 -3.946469E+04 1.785175E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.580182E+03 P = -8.209373E+02 -4.533780E+02 1.271804E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.257544E+05 P = -4.161665E+03 -3.433067E+04 -2.230899E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.56951E-07 sqme_ref* => 1.79521E-07 event_index* => 8 event_weight* => 1.38056E-05 event_weight_ref* => 1.57909E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4993875E+05; 2.5341874E+04, 5.3894751E+04,-2.4273963E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4797816E+05;-2.4465636E+04,-5.3323765E+04, 2.4093812E+05| 0.0000000E+00| 4) - 5 prt(o:21| 2.0830822E+03;-8.7623760E+02,-5.7098564E+02, 1.8015034E+03| 0.0000000E+00| 5) + 5 prt(o:21| 2.083082XE+03;-8.762376XE+02,-5.709856XE+02, 1.801503XE+03| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #8 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.79521E-07 Squared matrix el. (prc) = 2.25624E-08 Event weight (ref) = 1.57909E-05 Event weight (prc) = 1.98461E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3361222980.0, 3601284.0, 3842382860.0, 2580515999.0, 3568184670.0, 735623006.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2280904955.0, 1539004561.0, 852756080.0, 3258303332.0, 2415368508.0, 1295976056.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 4.950788936E-12 +sqme_rad = 4.95078893XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.497882E+05 P = 2.527464E+04 5.385094E+04 -2.426014E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.481274E+05 P = -2.453238E+04 -5.336726E+04 2.410754E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.027923E+02 P = 1.805539E+02 9.186084E+01 -9.305294E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.881521E+03 P = -9.228099E+02 -5.755396E+02 1.535349E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 8.895887E+04 P = 2.293156E+04 7.424874E+04 4.330067E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.837066E+05 P = -1.794896E+04 -3.946469E+04 1.785175E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.580182E+03 P = -8.209373E+02 -4.533780E+02 1.271804E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.257544E+05 P = -4.161665E+03 -3.433067E+04 -2.230899E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.25624E-08 sqme_ref* => 1.79521E-07 event_index* => 8 event_weight* => 1.98461E-06 event_weight_ref* => 1.57909E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4978825E+05; 2.5274639E+04, 5.3850938E+04,-2.4260139E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.4812744E+05;-2.4532383E+04,-5.3367260E+04, 2.4107535E+05| 0.0000000E+00| 4) - 5 prt(o:21| 2.0279232E+02; 1.8055394E+02, 9.1860838E+01,-9.3052939E+00| 0.0000000E+00| 5) - 6 prt(o:21| 1.8815206E+03;-9.2280989E+02,-5.7553957E+02, 1.5353488E+03| 0.0000000E+00| 6) + 5 prt(o:21| 2.027923XE+02; 1.805539XE+02, 9.186083XE+01,-9.305293XE+00| 0.000000XE+00| 5) + 6 prt(o:21| 1.881520XE+03;-9.228098XE+02,-5.755395XE+02, 1.535348XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #8 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.79521E-07 Squared matrix el. (prc) = 2.44130E-12 Event weight (ref) = 1.57909E-05 Event weight (prc) = 2.14739E-10 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3361222980.0, 3601284.0, 3842382860.0, 2580515999.0, 3568184670.0, 735623006.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2280904955.0, 1539004561.0, 852756080.0, 3258303332.0, 2415368508.0, 1295976056.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 4.950788936E-12 +sqme_rad = 4.95078893XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.497882E+05 P = 2.527464E+04 5.385094E+04 -2.426014E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.481274E+05 P = -2.453238E+04 -5.336726E+04 2.410754E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.027923E+02 P = 1.805539E+02 9.186084E+01 -9.305294E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.881521E+03 P = -9.228099E+02 -5.755396E+02 1.535349E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 8.895887E+04 P = 2.293156E+04 7.424874E+04 4.330067E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.837066E+05 P = -1.794896E+04 -3.946469E+04 1.785175E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.580182E+03 P = -8.209373E+02 -4.533780E+02 1.271804E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.257544E+05 P = -4.161665E+03 -3.433067E+04 -2.230899E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.44130E-12 sqme_ref* => 1.79521E-07 event_index* => 8 event_weight* => 2.14739E-10 event_weight_ref* => 1.57909E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 8.8958866E+04; 2.2931558E+04, 7.4248739E+04, 4.3300672E+04| 0.0000000E+00| 3) 4 prt(o:2| 1.8370659E+05;-1.7948956E+04,-3.9464693E+04, 1.7851746E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.5801816E+03;-8.2093725E+02,-4.5337797E+02, 1.2718036E+03| 0.0000000E+00| 5) - 6 prt(o:21| 2.2575437E+05;-4.1616648E+03,-3.4330669E+04,-2.2308994E+05| 0.0000000E+00| 6) + 5 prt(o:21| 1.580181XE+03;-8.209372XE+02,-4.533779XE+02, 1.271803XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 2.257543XE+05;-4.161664XE+03,-3.433066XE+04,-2.230899XE+05| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #8 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.79521E-07 Squared matrix el. (prc) = 4.95079E-12 Event weight (ref) = 1.57909E-05 Event weight (prc) = 4.35477E-10 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 3361222980.0, 3601284.0, 3842382860.0, 2580515999.0, 3568184670.0, 735623006.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2280904955.0, 1539004561.0, 852756080.0, 3258303332.0, 2415368508.0, 1295976056.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 4.950788936E-12 +sqme_rad = 4.95078893XE-12 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499388E+05 P = 2.534187E+04 5.389475E+04 -2.427396E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.479782E+05 P = -2.446564E+04 -5.332377E+04 2.409381E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.083082E+03 P = -8.762376E+02 -5.709856E+02 1.801503E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.497882E+05 P = 2.527464E+04 5.385094E+04 -2.426014E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.481274E+05 P = -2.453238E+04 -5.336726E+04 2.410754E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.027923E+02 P = 1.805539E+02 9.186084E+01 -9.305294E+00 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.881521E+03 P = -9.228099E+02 -5.755396E+02 1.535349E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 8.895887E+04 P = 2.293156E+04 7.424874E+04 4.330067E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 1.837066E+05 P = -1.794896E+04 -3.946469E+04 1.785175E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.580182E+03 P = -8.209373E+02 -4.533780E+02 1.271804E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.257544E+05 P = -4.161665E+03 -3.433067E+04 -2.230899E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 1.868213E+05 P = 1.911464E+04 4.032226E+04 -1.814137E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 8.644486E+04 P = 4.529927E+04 7.353426E+04 -3.660886E+03 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.750401E+03 P = -9.451524E+02 -7.211880E+02 2.480178E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 2.239835E+05 P = -6.346876E+04 -1.131353E+05 1.825944E+05 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 4.95079E-12 sqme_ref* => 1.79521E-07 event_index* => 8 event_weight* => 4.35477E-10 event_weight_ref* => 1.57909E-05 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 1.8682125E+05; 1.9114640E+04, 4.0322263E+04,-1.8141369E+05| 0.0000000E+00| 3) 4 prt(o:1| 8.6444859E+04; 4.5299272E+04, 7.3534261E+04,-3.6608858E+03| 0.0000000E+00| 4) - 5 prt(o:21| 2.7504015E+03;-9.4515241E+02,-7.2118804E+02, 2.4801780E+03| 0.0000000E+00| 5) - 6 prt(o:21| 2.2398349E+05;-6.3468759E+04,-1.1313534E+05, 1.8259440E+05| 0.0000000E+00| 6) + 5 prt(o:21| 2.750401XE+03;-9.451524XE+02,-7.211880XE+02, 2.480178XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 2.239834XE+05;-6.346875XE+04,-1.131353XE+05, 1.825944XE+05| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #9 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.02232E-08 Squared matrix el. (prc) = 2.86600E-07 Event weight (ref) = 1.47210E-06 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1484659988.0, 1927671876.0, 4126230753.0, 2962609785.0, 2346280463.0, 1525515485.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1981754768.0, 1371881432.0, 1113999651.0, 130493356.0, 4030926615.0, 1806134700.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.494556901E-10 +sqme_rad = 1.49455690XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487096E+05 P = 3.310905E+03 -8.615579E+04 -2.332867E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383402E+05 P = -3.704346E+03 8.193761E+04 2.237824E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.100863E+04 P = 2.291857E+03 4.527782E+03 9.769162E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.941646E+03 P = -1.898416E+03 -3.096039E+02 -2.648602E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.371521E+05 P = -3.308394E+04 -7.653858E+04 -2.220099E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.135808E+05 P = -3.442808E+03 7.328032E+04 2.005863E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.161504E+04 P = 5.041165E+02 4.781588E+03 1.057315E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.765212E+04 P = 3.602263E+04 -1.523326E+03 1.085044E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 2.86600E-07 sqme_ref* => 1.02232E-08 event_index* => 9 event_weight* => 0.00000E+00 event_weight_ref* => 1.47210E-06 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4997748E+05; 3.2628046E+03,-8.6671481E+04,-2.3444861E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.3713167E+05;-3.7502073E+03, 8.1445918E+04, 2.2267449E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.2890846E+04; 4.8740273E+02, 5.2255632E+03, 1.1774117E+04| 0.0000000E+00| 5) + 5 prt(o:21| 1.289084XE+04; 4.874027XE+02, 5.225563XE+03, 1.177411XE+04| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #9 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.02232E-08 Squared matrix el. (prc) = 9.93344E-09 Event weight (ref) = 1.47210E-06 Event weight (prc) = 1.43037E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1484659988.0, 1927671876.0, 4126230753.0, 2962609785.0, 2346280463.0, 1525515485.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1981754768.0, 1371881432.0, 1113999651.0, 130493356.0, 4030926615.0, 1806134700.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.494556901E-10 +sqme_rad = 1.49455690XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487096E+05 P = 3.310905E+03 -8.615579E+04 -2.332867E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383402E+05 P = -3.704346E+03 8.193761E+04 2.237824E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.100863E+04 P = 2.291857E+03 4.527782E+03 9.769162E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.941646E+03 P = -1.898416E+03 -3.096039E+02 -2.648602E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.371521E+05 P = -3.308394E+04 -7.653858E+04 -2.220099E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.135808E+05 P = -3.442808E+03 7.328032E+04 2.005863E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.161504E+04 P = 5.041165E+02 4.781588E+03 1.057315E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.765212E+04 P = 3.602263E+04 -1.523326E+03 1.085044E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 9.93344E-09 sqme_ref* => 1.02232E-08 event_index* => 9 event_weight* => 1.43037E-06 event_weight_ref* => 1.47210E-06 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.4870956E+05; 3.3109050E+03,-8.6155785E+04,-2.3328665E+05| 0.0000000E+00| 3) 4 prt(o:1| 2.3834017E+05;-3.7043461E+03, 8.1937607E+04, 2.2378235E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.1008630E+04; 2.2918569E+03, 4.5277823E+03, 9.7691618E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.9416457E+03;-1.8984158E+03,-3.0960385E+02,-2.6486017E+02| 0.0000000E+00| 6) + 5 prt(o:21| 1.100863XE+04; 2.291856XE+03, 4.527782XE+03, 9.769161XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.941645XE+03;-1.898415XE+03,-3.096038XE+02,-2.648601XE+02| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #9 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.02232E-08 Squared matrix el. (prc) = 1.40317E-10 Event weight (ref) = 1.47210E-06 Event weight (prc) = 2.02050E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1484659988.0, 1927671876.0, 4126230753.0, 2962609785.0, 2346280463.0, 1525515485.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1981754768.0, 1371881432.0, 1113999651.0, 130493356.0, 4030926615.0, 1806134700.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.494556901E-10 +sqme_rad = 1.49455690XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487096E+05 P = 3.310905E+03 -8.615579E+04 -2.332867E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383402E+05 P = -3.704346E+03 8.193761E+04 2.237824E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.100863E+04 P = 2.291857E+03 4.527782E+03 9.769162E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.941646E+03 P = -1.898416E+03 -3.096039E+02 -2.648602E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.371521E+05 P = -3.308394E+04 -7.653858E+04 -2.220099E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.135808E+05 P = -3.442808E+03 7.328032E+04 2.005863E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.161504E+04 P = 5.041165E+02 4.781588E+03 1.057315E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.765212E+04 P = 3.602263E+04 -1.523326E+03 1.085044E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.40317E-10 sqme_ref* => 1.02232E-08 event_index* => 9 event_weight* => 2.02050E-08 event_weight_ref* => 1.47210E-06 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.3715208E+05;-3.3083935E+04,-7.6538582E+04,-2.2200993E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.1358075E+05;-3.4428081E+03, 7.3280321E+04, 2.0058634E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.1615045E+04; 5.0411647E+02, 4.7815878E+03, 1.0573152E+04| 0.0000000E+00| 5) - 6 prt(o:21| 3.7652121E+04; 3.6022627E+04,-1.5233261E+03, 1.0850441E+04| 0.0000000E+00| 6) + 5 prt(o:21| 1.161504XE+04; 5.041164XE+02, 4.781587XE+03, 1.057315XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 3.765212XE+04; 3.602262XE+04,-1.523326XE+03, 1.085044XE+04| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #9 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 1.02232E-08 Squared matrix el. (prc) = 1.49456E-10 Event weight (ref) = 1.47210E-06 Event weight (prc) = 2.15209E-08 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1484659988.0, 1927671876.0, 4126230753.0, 2962609785.0, 2346280463.0, 1525515485.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-1) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 1981754768.0, 1371881432.0, 1113999651.0, 130493356.0, 4030926615.0, 1806134700.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 1.494556901E-10 +sqme_rad = 1.49455690XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.499775E+05 P = 3.262805E+03 -8.667148E+04 -2.344486E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.371317E+05 P = -3.750207E+03 8.144592E+04 2.226745E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.289085E+04 P = 4.874027E+02 5.225563E+03 1.177412E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.487096E+05 P = 3.310905E+03 -8.615579E+04 -2.332867E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.383402E+05 P = -3.704346E+03 8.193761E+04 2.237824E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.100863E+04 P = 2.291857E+03 4.527782E+03 9.769162E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.941646E+03 P = -1.898416E+03 -3.096039E+02 -2.648602E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.371521E+05 P = -3.308394E+04 -7.653858E+04 -2.220099E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.135808E+05 P = -3.442808E+03 7.328032E+04 2.005863E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.161504E+04 P = 5.041165E+02 4.781588E+03 1.057315E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.765212E+04 P = 3.602263E+04 -1.523326E+03 1.085044E+04 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.264346E+05 P = 2.890473E+03 -7.858530E+04 -2.123408E+05 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.236217E+05 P = 3.030647E+04 8.319946E+04 2.053437E+05 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.422644E+04 P = 4.662097E+02 5.685827E+03 1.303249E+04 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 3.571726E+04 P = -3.366315E+04 -1.029999E+04 -6.035314E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 1.49456E-10 sqme_ref* => 1.02232E-08 event_index* => 9 event_weight* => 2.15209E-08 event_weight_ref* => 1.47210E-06 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.2643462E+05; 2.8904732E+03,-7.8585296E+04,-2.1234084E+05| 0.0000000E+00| 3) 4 prt(o:2| 2.2362168E+05; 3.0306470E+04, 8.3199455E+04, 2.0534367E+05| 0.0000000E+00| 4) - 5 prt(o:21| 1.4226444E+04; 4.6620969E+02, 5.6858273E+03, 1.3032487E+04| 0.0000000E+00| 5) - 6 prt(o:21| 3.5717259E+04;-3.3663153E+04,-1.0299987E+04,-6.0353137E+03| 0.0000000E+00| 6) + 5 prt(o:21| 1.422644XE+04; 4.662096XE+02, 5.685827XE+03, 1.303248XE+04| 0.000000XE+00| 5) + 6 prt(o:21| 3.571725XE+04;-3.366315XE+04,-1.029998XE+04,-6.035313XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #10 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 4.92778E-09 Squared matrix el. (prc) = 7.74654E-07 Event weight (ref) = 1.03134E-04 Event weight (prc) = 0.00000E+00 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2574779949.0, 1613258.0, 957203242.0, 1832886249.0, 3404761797.0, 1098311093.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 379220129.0, 955940867.0, 625050135.0, 1046562733.0, 2664737320.0, 326107529.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 5.293057844E-10 +sqme_rad = 5.29305784XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.493156E+05 P = 1.186947E+05 2.140581E+05 4.742334E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.296477E+05 P = -1.116399E+05 -1.958949E+05 -4.358680E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982150E+04 P = -6.219397E+03 -1.857106E+04 -3.053953E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.215208E+03 P = -8.354423E+02 4.078269E+02 -7.825887E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.424422E+05 P = 1.046423E+05 2.116187E+05 5.518837E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.226841E+05 P = -1.083888E+05 -1.898795E+05 -4.225938E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.040489E+04 P = -7.175727E+03 -1.869021E+04 -3.942647E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.446880E+04 P = 1.092225E+04 -3.048961E+03 -8.986342E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 3 n_tot* => 5 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 7.74654E-07 sqme_ref* => 4.92778E-09 event_index* => 10 event_weight* => 0.00000E+00 event_weight_ref* => 1.03134E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4989885E+05; 1.1890374E+05, 2.1459629E+05, 4.7537023E+04| 0.0000000E+00| 3) 4 prt(o:2| 2.2911259E+05;-1.1144776E+05,-1.9540027E+05,-4.3482330E+04| 0.0000000E+00| 4) - 5 prt(o:21| 2.0988556E+04;-7.4559875E+03,-1.9196021E+04,-4.0546932E+03| 0.0000000E+00| 5) + 5 prt(o:21| 2.098855XE+04;-7.455987XE+03,-1.919602XE+04,-4.054693XE+03| 0.000000XE+00| 5) ======================================================================== ======================================================================== Event #10 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 4.92778E-09 Squared matrix el. (prc) = 3.94882E-09 Event weight (ref) = 1.03134E-04 Event weight (prc) = 8.26455E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2574779949.0, 1613258.0, 957203242.0, 1832886249.0, 3404761797.0, 1098311093.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 379220129.0, 955940867.0, 625050135.0, 1046562733.0, 2664737320.0, 326107529.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 5.293057844E-10 +sqme_rad = 5.29305784XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.493156E+05 P = 1.186947E+05 2.140581E+05 4.742334E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.296477E+05 P = -1.116399E+05 -1.958949E+05 -4.358680E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982150E+04 P = -6.219397E+03 -1.857106E+04 -3.053953E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.215208E+03 P = -8.354423E+02 4.078269E+02 -7.825887E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.424422E+05 P = 1.046423E+05 2.116187E+05 5.518837E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.226841E+05 P = -1.083888E+05 -1.898795E+05 -4.225938E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.040489E+04 P = -7.175727E+03 -1.869021E+04 -3.942647E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.446880E+04 P = 1.092225E+04 -3.048961E+03 -8.986342E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 3.94882E-09 sqme_ref* => 4.92778E-09 event_index* => 10 event_weight* => 8.26455E-05 event_weight_ref* => 1.03134E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4931560E+05; 1.1869470E+05, 2.1405809E+05, 4.7423341E+04| 0.0000000E+00| 3) 4 prt(o:2| 2.2964769E+05;-1.1163986E+05,-1.9589486E+05,-4.3586799E+04| 0.0000000E+00| 4) - 5 prt(o:21| 1.9821498E+04;-6.2193968E+03,-1.8571060E+04,-3.0539532E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.2152085E+03;-8.3544228E+02, 4.0782685E+02,-7.8258868E+02| 0.0000000E+00| 6) + 5 prt(o:21| 1.982149XE+04;-6.219396XE+03,-1.857106XE+04,-3.053953XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.215208XE+03;-8.354422XE+02, 4.078268XE+02,-7.825886XE+02| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #10 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 4.92778E-09 Squared matrix el. (prc) = 4.49653E-10 Event weight (ref) = 1.03134E-04 Event weight (prc) = 9.41086E-06 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2574779949.0, 1613258.0, 957203242.0, 1832886249.0, 3404761797.0, 1098311093.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 379220129.0, 955940867.0, 625050135.0, 1046562733.0, 2664737320.0, 326107529.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 5.293057844E-10 +sqme_rad = 5.29305784XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.493156E+05 P = 1.186947E+05 2.140581E+05 4.742334E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.296477E+05 P = -1.116399E+05 -1.958949E+05 -4.358680E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982150E+04 P = -6.219397E+03 -1.857106E+04 -3.053953E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.215208E+03 P = -8.354423E+02 4.078269E+02 -7.825887E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.424422E+05 P = 1.046423E+05 2.116187E+05 5.518837E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.226841E+05 P = -1.083888E+05 -1.898795E+05 -4.225938E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.040489E+04 P = -7.175727E+03 -1.869021E+04 -3.942647E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.446880E+04 P = 1.092225E+04 -3.048961E+03 -8.986342E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 4.49653E-10 sqme_ref* => 4.92778E-09 event_index* => 10 event_weight* => 9.41086E-06 event_weight_ref* => 1.03134E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-2| 2.4244221E+05; 1.0464228E+05, 2.1161867E+05, 5.5188367E+04| 0.0000000E+00| 3) 4 prt(o:2| 2.2268411E+05;-1.0838880E+05,-1.8987950E+05,-4.2259378E+04| 0.0000000E+00| 4) - 5 prt(o:21| 2.0404888E+04;-7.1757273E+03,-1.8690210E+04,-3.9426468E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.4468799E+04; 1.0922254E+04,-3.0489615E+03,-8.9863420E+03| 0.0000000E+00| 6) + 5 prt(o:21| 2.040488XE+04;-7.175727XE+03,-1.869021XE+04,-3.942646XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.446879XE+04; 1.092225XE+04,-3.048961XE+03,-8.986342XE+03| 0.000000XE+00| 6) ======================================================================== ======================================================================== Event #10 ------------------------------------------------------------------------ Unweighted = F Normalization = 'sigma' Helicity handling = drop Keep correlations = F ------------------------------------------------------------------------ Squared matrix el. (ref) = 4.92778E-09 Squared matrix el. (prc) = 5.29306E-10 Event weight (ref) = 1.03134E-04 Event weight (prc) = 1.10779E-05 ------------------------------------------------------------------------ Selected MCI group = 2 Selected term = 5 Selected channel = 2 ------------------------------------------------------------------------ Passed selection = T Reweighting factor = 1.00000E+00 Analysis flag = T ======================================================================== Event transform: trivial (hard process) ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 2574779949.0, 1613258.0, 957203242.0, 1832886249.0, 3404761797.0, 1098311093.0, ] Beginning substream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Initial stream = [ 1308083549.0, 3131218167.0, 1156925658.0, 3650761735.0, 3265303909.0, 2003036106.0, ] Number of tries = 1 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ======================================================================== ======================================================================== Event transform: NLO ------------------------------------------------------------------------ Associated process: 'openloops_12_p1' RNG Stream generator Current position = [ 379220129.0, 955940867.0, 625050135.0, 1046562733.0, 2664737320.0, 326107529.0, ] Beginning substream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Initial stream = [ 3370997467.0, 4205268159.0, 1216339063.0, 1879087637.0, 849696509.0, 200114322.0, ] Number of tries = 0 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 -sqme_rad = 5.293057844E-10 +sqme_rad = 5.29305784XE-10 i_evaluation = 0 ------------------------------------------------------------------------ Radiated particle sets: Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 Particle 3 [o] f(-2) E = 2.498989E+05 P = 1.189037E+05 2.145963E+05 4.753702E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.291126E+05 P = -1.114478E+05 -1.954003E+05 -4.348233E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.098856E+04 P = -7.455988E+03 -1.919602E+04 -4.054693E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.493156E+05 P = 1.186947E+05 2.140581E+05 4.742334E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.296477E+05 P = -1.116399E+05 -1.958949E+05 -4.358680E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 1.982150E+04 P = -6.219397E+03 -1.857106E+04 -3.053953E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.215208E+03 P = -8.354423E+02 4.078269E+02 -7.825887E+02 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-2) E = 2.424422E+05 P = 1.046423E+05 2.116187E+05 5.518837E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(2) E = 2.226841E+05 P = -1.083888E+05 -1.898795E+05 -4.225938E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.040489E+04 P = -7.175727E+03 -1.869021E+04 -3.942647E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.446880E+04 P = 1.092225E+04 -3.048961E+03 -8.986342E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ Particle set: ------------------------------------------------------------------------ Particle 1 [i] f(11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 2 [i] f(-11) E = 2.500000E+05 P = 0.000000E+00 0.000000E+00 -2.500000E+05 T = 0.000000000E+00 Children: 3 4 5 6 Particle 3 [o] f(-1) E = 2.434709E+05 P = 1.157767E+05 2.091137E+05 4.631699E+04 T = 0.000000000E+00 Parents: 1 2 Particle 4 [o] f(1) E = 2.217269E+05 P = -9.968093E+04 -1.951835E+05 -3.361440E+04 T = 0.000000000E+00 Parents: 1 2 Particle 5 [o] f(21) E = 2.153698E+04 P = -7.725518E+03 -1.966859E+04 -4.159853E+03 T = 0.000000000E+00 Parents: 1 2 Particle 6 [o] f(21) E = 1.326530E+04 P = -8.370269E+03 5.738346E+03 -8.542730E+03 T = 0.000000000E+00 Parents: 1 2 ------------------------------------------------------------------------ ======================================================================== Local variables: ------------------------------------------------------------------------ sqrts* = 5.00000E+05 sqrts_hat* => 5.00000E+05 n_in* => 2 n_out* => 4 n_tot* => 6 $process_id* => "openloops_12_p1" process_num_id* => [unknown integer] sqme* => 5.29306E-10 sqme_ref* => 4.92778E-09 event_index* => 10 event_weight* => 1.10779E-05 event_weight_ref* => 1.03134E-04 event_excess* => 0.00000E+00 ------------------------------------------------------------------------ subevent: 1 prt(i:11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00,-2.5000000E+05| 0.0000000E+00| 1) 2 prt(i:-11|-2.5000000E+05; 0.0000000E+00, 0.0000000E+00, 2.5000000E+05| 0.0000000E+00| 2) 3 prt(o:-1| 2.4347085E+05; 1.1577672E+05, 2.0911371E+05, 4.6316987E+04| 0.0000000E+00| 3) 4 prt(o:1| 2.2172687E+05;-9.9680934E+04,-1.9518347E+05,-3.3614404E+04| 0.0000000E+00| 4) - 5 prt(o:21| 2.1536975E+04;-7.7255182E+03,-1.9668586E+04,-4.1598530E+03| 0.0000000E+00| 5) - 6 prt(o:21| 1.3265303E+04;-8.3702695E+03, 5.7383460E+03,-8.5427301E+03| 0.0000000E+00| 6) + 5 prt(o:21| 2.153697XE+04;-7.725518XE+03,-1.966858XE+04,-4.159853XE+03| 0.000000XE+00| 5) + 6 prt(o:21| 1.326530XE+04;-8.370269XE+03, 5.738346XE+03,-8.542730XE+03| 0.000000XE+00| 6) ======================================================================== Index: trunk/tests/functional_tests/lcio_7.sh =================================================================== --- trunk/tests/functional_tests/lcio_7.sh (revision 8839) +++ trunk/tests/functional_tests/lcio_7.sh (revision 8840) @@ -1,19 +1,19 @@ #!/bin/sh ### Check WHIZARD for a simple test process echo "Running script $0" if test -f OCAML_FLAG -a -f LCIO_FLAG; then name=`basename @script@` ./run_whizard.sh @script@ --no-logging echo "Contents of ${name}a.evt" >> $name.log cat ${name}a.evt | grep 'prt(' \ - | sed -e 's/^\(.*|.*|\) .*\(|.*\)$/\1 *** \2/' >> $name.log + | sed -e 's/^\(.*|.*|\).*\(|.*\)$/\1 *** \2/' >> $name.log echo "Contents of ${name}b.evt" >> $name.log cat ${name}b.evt | grep 'prt(' \ - | sed -e 's/^\(.*|.*|\) .*\(|.*\)$/\1 *** \2/' >> $name.log + | sed -e 's/^\(.*|.*|\).*\(|.*\)$/\1 *** \2/' >> $name.log diff ref-output/`basename @script@`.ref `basename @script@`.log else echo "|=============================================================================|" echo "No LCIO or no O'Mega matrix elements available, test skipped" exit 77 fi Index: trunk/tests/functional_tests/hepmc_8.sh =================================================================== --- trunk/tests/functional_tests/hepmc_8.sh (revision 8839) +++ trunk/tests/functional_tests/hepmc_8.sh (revision 8840) @@ -1,19 +1,19 @@ #!/bin/sh ### Check WHIZARD for a simple test process echo "Running script $0" if test -f OCAML_FLAG -a -f HEPMC2_FLAG || test -f OCAML_FLAG -a -f HEPMC3_FLAG; then name=`basename @script@` ./run_whizard.sh @script@ --no-logging echo "Contents of ${name}a.evt" >> $name.log cat ${name}a.evt | grep 'prt(' \ - | sed -e 's/^\(.*|.*|\) .*\(|.*\)$/\1 *** \2/' >> $name.log + | sed -e 's/^\(.*|.*|\).*\(|.*\)$/\1 *** \2/' >> $name.log echo "Contents of ${name}b.evt" >> $name.log cat ${name}b.evt | grep 'prt(' \ - | sed -e 's/^\(.*|.*|\) .*\(|.*\)$/\1 *** \2/' >> $name.log + | sed -e 's/^\(.*|.*|\).*\(|.*\)$/\1 *** \2/' >> $name.log diff ref-output/`basename @script@`.ref `basename @script@`.log else echo "|=============================================================================|" echo "HepMC disabled or no O'Mega matrix elements available, test skipped" exit 77 fi Index: trunk/tests/functional_tests/openloops_12.sh =================================================================== --- trunk/tests/functional_tests/openloops_12.sh (revision 8839) +++ trunk/tests/functional_tests/openloops_12.sh (revision 8840) @@ -1,18 +1,18 @@ #!/bin/sh ### Testing the integration of the real component of ee -> jjj ### and the simulation of events. echo "Running script $0" if test -f OCAML_FLAG -a -f OPENLOOPS_FLAG -a -f FASTJET_FLAG; then name=`basename @script@` ./run_whizard.sh @script@ --no-logging mv $name.log $name.log.tmp cat $name.log.tmp | sed -e 's/Loading library:.*/Loading library: [...]/' > $name.log cat ${name}_p1_fks_regions.out >> $name.log echo "Contents of ${name}_p1.debug:" >> $name.log - cat ${name}_p1.debug >> $name.log + cat ${name}_p1.debug | sed -e 's/\(sqme_rad = [0-9]\.[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]\)[0-9]E-\([0-9][0-9]\)/\1XE-\2/' -e '/prt(o:21/s/[0-9]E/XE/g' >> $name.log diff ref-output/$name.ref $name.log else echo "|=============================================================================|" echo "No O'Mega/OpenLoops matrix elements / FastJet available. Test skipped." exit 77 fi Index: trunk/tests/functional_tests/lcio_rd.cpp =================================================================== --- trunk/tests/functional_tests/lcio_rd.cpp (revision 8839) +++ trunk/tests/functional_tests/lcio_rd.cpp (revision 8840) @@ -1,529 +1,535 @@ #include "lcio.h" #include +#include #include "IO/LCReader.h" #include "IMPL/LCTOOLS.h" #include "EVENT/LCRunHeader.h" #include "EVENT/SimCalorimeterHit.h" #include "EVENT/CalorimeterHit.h" #include "EVENT/RawCalorimeterHit.h" #include "UTIL/CellIDDecoder.h" #include "UTIL/LCTime.h" #include using namespace std ; using namespace lcio ; std::string getSimulatorStatusString(const MCParticle* mcp=0){ if( mcp == 0 ) { - + std::stringstream str ; str << "simulator status bits: [sbvtcls] " << " s: created in simulation" << " b: backscatter" << " v: vertex is not endpoint of parent" << " t: decayed in tracker" << " c: decayed in calorimeter" << " l: has left detector" << " s: stopped" << " o: overlay" << std::endl ; return str.str() ; } std::string s("[ 0 ]") ; if( mcp->getSimulatorStatus() == 0 ) return s ; if( mcp->isCreatedInSimulation() ) s[1]='s' ; else s[1]=' ' ; if( mcp->isBackscatter() ) s[2]='b' ; else s[2]=' ' ; if( mcp->vertexIsNotEndpointOfParent() ) s[3]='v' ; else s[3]=' ' ; if( mcp->isDecayedInTracker() ) s[4]='t' ; else s[4]=' ' ; if( mcp->isDecayedInCalorimeter() ) s[5]='c' ; else s[5]=' ' ; if( mcp->hasLeftDetector() ) s[6]='l' ; else s[6]=' ' ; if( mcp->isStopped() ) s[7]='s' ; else s[7]=' ' ; if( mcp->isOverlay() ) s[8]='o' ; else s[8]=' ' ; return s ; } // For backwards compatibility of the reference output in the functional tests // output of the double parameters are output as "float" void printParameters( const EVENT::LCParameters& params ){ StringVec intKeys ; int nIntParameters = params.getIntKeys( intKeys ).size() ; for(int i=0; i< nIntParameters ; i++ ){ IntVec intVec ; params.getIntVals( intKeys[i], intVec ) ; int nInt = intVec.size() ; cout << " parameter " << intKeys[i] << " [int]: " ; if( nInt == 0 ){ cout << " [empty] " << std::endl ; } for(int j=0; j< nInt ; j++ ){ cout << intVec[j] << ", " ; } cout << endl ; } StringVec floatKeys ; int nFloatParameters = params.getFloatKeys( floatKeys ).size() ; for(int i=0; i< nFloatParameters ; i++ ){ FloatVec floatVec ; params.getFloatVals( floatKeys[i], floatVec ) ; int nFloat = floatVec.size() ; cout << " parameter " << floatKeys[i] << " [float]: " ; if( nFloat == 0 ){ cout << " [empty] " << std::endl ; } for(int j=0; j< nFloat ; j++ ){ cout << floatVec[j] << ", " ; } cout << endl ; } #if LCIO_VERSION_GE (2, 17) StringVec doubleKeys ; int nDoubleParameters = params.getDoubleKeys( doubleKeys ).size() ; for(int i=0; i< nDoubleParameters ; i++ ){ DoubleVec doubleVec ; params.getDoubleVals( doubleKeys[i], doubleVec ) ; int nDouble = doubleVec.size() ; cout << " parameter " << doubleKeys[i] << " [float]: " ; if( nDouble == 0 ){ cout << " [empty] " << std::endl ; } for(int j=0; j< nDouble ; j++ ){ cout << doubleVec[j] << ", " ; } cout << endl ; } #endif StringVec stringKeys ; int nStringParameters = params.getStringKeys( stringKeys ).size() ; for(int i=0; i< nStringParameters ; i++ ){ StringVec stringVec ; params.getStringVals( stringKeys[i], stringVec ) ; int nString = stringVec.size() ; cout << " parameter " << stringKeys[i] << " [string]: " ; if( nString == 0 ){ cout << " [empty] " << std::endl ; } for(int j=0; j< nString ; j++ ){ cout << stringVec[j] << ", " ; } cout << endl ; } } void printMCParticles(const EVENT::LCCollection* col ) { if( col->getTypeName() != LCIO::MCPARTICLE ){ cout << " collection not of type " << LCIO::MCPARTICLE << endl ; return ; } cout << endl << "--------------- " << "print out of " << LCIO::MCPARTICLE << " collection " << "--------------- " << endl ; cout << endl << " flag: 0x" << hex << col->getFlag() << dec << endl ; printParameters( col->getParameters() ) ; int nParticles = col->getNumberOfElements() ; cout << " " << getSimulatorStatusString() << std::endl ; // fill map with particle pointers and collection indices typedef std::map< MCParticle*, int > PointerToIndexMap ; PointerToIndexMap p2i_map ; std::vector moms ; /* cout << endl; MCParticle* part=NULL; cout << header(part); cout << tail(part); for( int i=0 ; i< nParticles ; i++ ){ part = dynamic_cast( col->getElementAt( i )); cout << lcio_short(part, col); //WARNING! //not exact the same output as the code below: //<< lcio_short prints the id's of the parents/daughters particles, //the "old" version prints the position in the collection } */ for( int k=0; k( col->getElementAt( k ) ) ; p2i_map[ part ] = k ; moms.push_back( part ) ; } std::cout << endl << "[ id ]index| PDG | px, py, pz | energy |gen|[simstat ]| vertex x, y , z | mass | charge | spin | colorflow | [parents] - [daughters]" << endl << endl ; // loop over collection - preserve order for( int index = 0 ; index < nParticles ; index++){ MCParticle* part = dynamic_cast( col->getElementAt( index ) ) ; #if LCIO_VERSION_GE (2, 13) printf("[%8.8d]", part->id() - 1); #else printf("[%8.8d]", part->id() ); #endif printf("%5d|" , index ); printf("%10d|" , part->getPDG() ); printf("% 1.2e,% 1.2e,% 1.2e|" , part->getMomentum()[0] , part->getMomentum()[1] , part->getMomentum()[2] ); printf("% 1.2e|" , part->getEnergy() ) ; printf(" %1d |" , part->getGeneratorStatus() ); printf("%s|" , getSimulatorStatusString( part ).c_str() ); printf("% 1.2e,% 1.2e,% 1.2e|" , part->getVertex()[0] , part->getVertex()[1] , part->getVertex()[2] ); - printf("% 1.2e|" , part->getMass() ) ; + float mass; + if (abs (part->getMass ()) < part->getEnergy () * std::numeric_limits::epsilon()) + mass = 0; + else + mass = part->getMass (); + printf("% 1.2e|" , mass ) ; printf("% 1.2e|" , part->getCharge() ) ; printf("% 1.2e,% 1.2e,% 1.2e|" , part->getSpin()[0] , part->getSpin()[1] , part->getSpin()[2] ); printf(" (%d, %d) |" , part->getColorFlow()[0] , part->getColorFlow()[1] ); cout << " [" ; for(unsigned int k=0;kgetParents().size();k++){ if(k>0) cout << "," ; cout << p2i_map[ part->getParents()[k] ] ; } cout << "] - [" ; for(unsigned int k=0;kgetDaughters().size();k++){ if(k>0) cout << "," ; cout << p2i_map[ part->getDaughters()[k] ] ; } cout << "] " << endl ; } cout << endl << "-------------------------------------------------------------------------------- " << endl ; } int main(int argc, char** argv ){ char* FILEN ; int runNumber=0 ; int evtNumber=0 ; int nthEvent=1 ; // read file name from command line (only argument) if( argc < 3 ) { cout << " usage: dumpevent filename runNum evtNum " << endl ; cout << " or: dumpevent filename n " << endl ; cout << " where the first dumps the event with the specified run and event number" << endl ; cout << " and the second simply dumps the n-th event in the file" << endl << endl ; cout << " set the environment variable LCIO_READ_COL_NAMES to a space separated list" << endl ; cout << " of collection names that you would like to dump (all are dumped if not set)" << endl ; exit(1) ; } FILEN = argv[1] ; bool dumpNthEvent( argc == 3 ) ; if( dumpNthEvent ) { nthEvent = atoi( argv[2] ) ; if( nthEvent < 1 ) { cout << " usage: dumpevent filename n - whith n > 0 ! " << endl ; exit(1) ; } }else{ runNumber = atoi( argv[2] ) ; evtNumber = atoi( argv[3] ) ; } // // set the default encoding for cellid's according to the old Mokka convention // CellIDDecoder::setDefaultEncoding("M:3,S-1:3,I:9,J:9,K-1:6") ; // CellIDDecoder::setDefaultEncoding("M:3,S-1:3,I:9,J:9,K-1:6") ; // CellIDDecoder::setDefaultEncoding("M:3,S-1:3,I:9,J:9,K-1:6") ; LCReader* lcReader ; if( dumpNthEvent ) lcReader = LCFactory::getInstance()->createLCReader() ; else lcReader = LCFactory::getInstance()->createLCReader(LCReader::directAccess) ; // // ------ check if LCIO_READ_COL_NAMES is set ------------- // // char* rColChar = getenv ("LCIO_READ_COL_NAMES"); // // if ( rColChar != 0 ) { // // std::vector< std::string > colSubset ; // std::stringstream sts( rColChar ) ; // std::string colName; // // while( sts >> colName) { // // colSubset.push_back( colName ) ; // } // // lcReader->setReadCollectionNames( colSubset ) ; // } // //----------------------------------------------------------- LCEvent* evt(0) ; try{ lcReader->open( FILEN ) ; if( dumpNthEvent ) { if( nthEvent > 0 ) lcReader->skipNEvents( nthEvent - 1 ) ; evt = lcReader->readNextEvent() ; }else{ evt = lcReader->readEvent(runNumber, evtNumber) ; } if( !evt ){ if(dumpNthEvent){ cout << " less than " << nthEvent << " events in file " << FILEN << endl ; }else{ cout << " couldn't find event " << evtNumber << " - run " << runNumber << " in file " << FILEN << endl ; } exit(1) ; } // the event: cout << endl << "============================================================================" << endl ; cout << " Event : " << evt->getEventNumber() << " - run: " << evt->getRunNumber() << " - timestamp " << evt->getTimeStamp() << " - weight " << evt->getWeight() << endl ; cout << "============================================================================" << endl ; LCTime evtTime( evt->getTimeStamp() ) ; cout << " date: " << evtTime.getDateString() << endl ; cout << " detector : " << evt->getDetectorName() << endl ; cout << " event parameters: " << endl ; printParameters( evt->getParameters() ) ; const std::vector< std::string >* strVec = evt->getCollectionNames() ; // loop over all collections: std::vector< std::string >::const_iterator name ; for( name = strVec->begin() ; name != strVec->end() ; name++){ LCCollection* col = evt->getCollection( *name ) ; cout << endl << " collection name : " << *name << endl << " parameters: " << endl ; // printParameters( col->getParameters() ) ; // call the detailed print functions depending on type name if( evt->getCollection( *name )->getTypeName() == LCIO::MCPARTICLE ){ printMCParticles( col ) ; // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::SIMTRACKERHIT ){ // // printSimTrackerHits( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::TPCHIT ){ // // printTPCHits( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::TRACKERHIT ){ // // printTrackerHits( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::TRACKERHITPLANE ){ // // printTrackerHitPlane( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::TRACKERHITZCYLINDER ){ // // printTrackerHitZCylinder( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::SIMCALORIMETERHIT ){ // // printSimCalorimeterHits( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::CALORIMETERHIT ){ // // printCalorimeterHits( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::RAWCALORIMETERHIT ){ // // printRawCalorimeterHits( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::LCFLOATVEC ){ // // printLCFloatVecs( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::LCINTVEC ){ // // printLCIntVecs( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::LCSTRVEC ){ // // printLCStrVecs( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::TRACK ){ // // printTracks( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::CLUSTER ){ // // printClusters( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::RECONSTRUCTEDPARTICLE ){ // // printReconstructedParticles( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::VERTEX ){ // // printVertices( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::LCGENERICOBJECT ){ // // printLCGenericObjects( col ) ; // // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::LCRELATION ){ // // printRelation( col ) ; // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::TRACKERRAWDATA ){ // // printTrackerRawData( col ) ; // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::TRACKERDATA ){ // // printTrackerData( col ) ; // } // else if( evt->getCollection( *name )->getTypeName() == LCIO::TRACKERPULSE ){ // // printTrackerPulse( col ) ; // } } } // LCTOOLS::dumpEventDetailed( evt ) ; lcReader->close() ; } catch( IOException& e) { cout << e.what() << endl ; exit(1) ; } return 0 ; }